def environment__get_agent_by_id(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.get_agent_by_id \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__get_agent_by_id in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print("Getting a bank with id: bank_test_config_id")
print(environment.get_agent_by_id("bank_test_config_id"))
def environment__write_environment_file(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.write_environment_file \n"
text = "and writes a mirror of the config file \n"
text = "in the directory from which it was called \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__write_environment_file in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print("Writing the environment file")
environment.write_environment_file(identifier)
def environment__check_global_transaction_balance(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.check_global_transaction_balance \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__check_global_transaction_balance in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print("Checking global consistency of deposits:")
if environment.check_global_transaction_balance("deposits") == True:
print("Consistent")
else:
print("Not consistent")
def environment__add_static_parameter(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.add_static_parameter \n"
text = "Should add 'test':0.66 to static parameters \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__add_static_parameter in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print(environment.static_parameters)
print("Adding 'test':0.66")
environment.add_static_parameter("test", 0.66)
print(environment.static_parameters)
def environment__read_transactions_for_banks(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.read_transactions_for_banks \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__read_transactions_for_banks in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print("Clearing accounts of the bank:")
environment.banks[0].clear_accounts() # let's use the first bank
print(environment.banks[0])
print("Reading transactions: ")
environment.read_transactions_for_banks(environment.bank_directory)
print(environment.banks[0])
def transaction__add_transaction(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
text = "This test checks transaction.add_transaction \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test transaction__add_transaction in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
print("Creating a transaction")
transaction = Transaction()
print("Assigning values")
transaction.this_transaction("type", "asset", "test_household", "test_firm", 1, 2, 3, 4)
print("Adding the transaction to the books")
transaction.add_transaction(environment)
print("The transaction:")
print(transaction)
print("The firm:")
print(environment.get_agent_by_id("test_firm"))
print("The household:")
print(environment.get_agent_by_id("test_household"))
def setUp(self):
self.w1 = WeatherModel(1)
self.w2 = WeatherModel(2)
self.e1 = Environment(10,15)
self.e2 = Environment(20,25)
loc = [2, 1]
self.tile = self.e1.get_tile(loc)
self.teff1 = Teff(self.tile)
def transaction__clear_accounts(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
text = "This test checks transaction.clear_accounts \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test transaction__clear_accounts in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
# bank = Bank()
# bank.identifier = "test_bank"
# environment.banks.append(bank)
# generate a firm
# firm = Firm()
# firm.identifier = "test_firm"
# environment.firms.append(firm)
# generate a household
# household = Household()
# household.identifier = "test_household"
# environment.households.append(household)
#
# TESTING
#
print("Before clearing one bank's accounts")
for bank in environment.banks:
print(bank)
for household in environment.households:
print(household)
environment.get_agent_by_id("bank_test_config_id").clear_accounts()
print("After clearing one bank's accounts")
for bank in environment.banks:
print(bank)
for household in environment.households:
print(household)
def updater__endow_labour(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.updater import Updater
text = "This test checks updater.endow_labour \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test updater__endow_labour in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
model = Updater(environment)
environment.get_agent_by_id("test_household").sweep_labour = 0
print(environment.get_agent_by_id("test_household").sweep_labour)
print("Endowing labour")
model.endow_labour(environment, 0)
print(environment.get_agent_by_id("test_household").sweep_labour)
def test_mountains(self):
mount = ImageFeature("tests/img/mount_200.png")
gen_model = AbstractModel(os.path.abspath(os.path.dirname(sys.argv[0])) + "/tests/models/pine_tree/Pine_4m.obj", 0.01, (0, 0))
v1 = Vegetation(geom.box(20, 20, 180, 180), gen_model, 10)
v1.models.append(Model((5, 5), gen_model))
v1.models.append(Model((195, 195), gen_model))
env = Environment([mount, v1])
env.init_heightmap(200, 200)
f = open('mountains.pickle', 'wb')
pickle.dump(env, f)
f.close()
env.export_heightmap("bla.png", 200, 200)
def test_pickle(self):
a = Environment([Feature()])
# moche mais en attendant que ça marche...
a.init_heightmap(10, 10)
b = HeightMap(10, 10, z_func=lambda z: 100 * z[0] + z[1])
a.heightmap = b
f = open('/tmp/waves.p', 'wb')
pickle.dump(a, f)
f.close()
g = open('/tmp/waves.p', 'rb')
b = pickle.load(g)
g.close()
self.assertEqual(a.heightmap, b.heightmap)
class TestClassEnvironment(unittest.TestCase):
def setUp(self):
self.background = FeatureTest(100, influence="notall", val_influence=1)
self.background.shape = geom.box(5, 5, 45, 45)
self.up = FeatureTest(150, influence="notall", val_influence=1)
self.up.shape = geom.box(10, 10, 30, 30)
self.rep = FeatureTestReplace(0, influence="notall", val_influence=1)
self.rep.shape = geom.box(10, 10, 30, 30)
self.forest = Vegetation(geom.box(5, 5, 45, 45), model=AbstractModel(), tree_number=50)
self.env = Environment([self.rep, self.up, self.background, self.forest])
def test_models(self):
self.assertLess(len(self.env.models), 50)
self.assertGreater(len(self.env.models), 25)
self.env.export_heightmap("temp_env.png", 50, 50)
def environment__check_agent_homogeneity(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.check_agent_homogeneity \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__check_agent_homogeneity in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
bank = Bank()
bank.identifier = "new bank"
environment.banks.append(bank)
environment.agents = [environment.banks, environment.firms, environment.households]
print("Are banks homogeneous?")
print(environment.check_agent_homogeneity("banks"))
print("Changing one of the banks...")
environment.get_agent_by_id("new bank").parameters["active"] = 4
print("Are banks homogeneous?")
print(environment.check_agent_homogeneity("banks"))
def setUp(self):
self.background = FeatureTest(100, influence="notall", val_influence=1)
self.background.shape = geom.box(5, 5, 45, 45)
self.up = FeatureTest(150, influence="notall", val_influence=1)
self.up.shape = geom.box(10, 10, 30, 30)
self.rep = FeatureTestReplace(0, influence="notall", val_influence=1)
self.rep.shape = geom.box(10, 10, 30, 30)
self.forest = Vegetation(geom.box(5, 5, 45, 45), model=AbstractModel(), tree_number=50)
self.env = Environment([self.rep, self.up, self.background, self.forest])
def environment__set_identifier(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.set_identifier \n"
text = "and sets the identifier to XYZ \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__set_identifier in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
text = "Identifier: "
text = text + environment.identifier
print(text)
print("Changing identifier to XYZ")
environment.set_identifier("XYZ")
text = "Identifier: "
text = text + environment.identifier
print(text)
def environment__set_variable_parameters(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.set_variable_parameters \n"
text = "and sets them to 'test': 0.55-0.66 \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__set_variable_parameters in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print("Variable parameters:")
print(environment.get_variable_parameters())
print("Changing variable parameters to 'test': 0.55-0.66")
environment.set_variable_parameters({'test': [0.55, 0.66]})
print("Variable parameters:")
print(environment.get_variable_parameters())
def environment__add_shock(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
text = "This test checks environment.add_shock \n"
text = text + "and adds to them [3, 4, 'test']\n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test environment__add_shock in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print("Shocks:")
print(environment.get_shocks())
print("Adding shock [3, 4, 'test']")
environment.add_shock([3, 4, "test"])
print("Shocks:")
print(environment.get_shocks())
def updater__consume_rationed(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.updater import Updater
text = "This test checks updater.consume_rationed \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test updater__consume_rationed in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
model = Updater(environment)
model.sell_labour(environment, 0)
print(environment.households[0])
print("Consuming the production")
model.consume_rationed(environment, 0)
print(environment.households[0])
def network__subnetwork_by_type(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.network import Network
text = "This test checks network.subnetwork_by_type \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test network__subnetwork_by_type in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print("Properties of the full network:")
print(nx.info(environment.network.transactions))
print("Creating the subnetwork by type")
G = environment.network.subnetwork_by_type("loans")
print("Properties of the subnetwork:")
print(nx.info(G))
def network__set_transactions(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.network import Network
text = "This test checks network.set_transactions \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test network__set_transactions in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
print(nx.info(environment.network.get_transactions()))
print("Setting transactions to an empty graph")
empty_graph = nx.MultiDiGraph()
environment.network.set_transactions(empty_graph)
print(nx.info(environment.network.get_transactions()))
def helper__translog(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.helper import Helper
text = "This test checks helper.translog \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info('START logging for test helper__translog in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
#
# TESTING
#
helper = Helper()
production = helper.translog(3, 2, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5)
print("Calculating production in translog:")
print(production)
def test_standard_environment_creation(self):
dummy_map = "/o/..\n" \
"S.../"
e = Environment(self.settings, dummy_map)
self.assertEqual(15, len(e.get_all_tiles()))
# First tile is walkable grass and not dirt
first_tile = e.tile_at(Position(0, 0))
self.assertTrue(first_tile.is_walkable())
self.assertFalse(first_tile.is_dirt())
self.assertTrue(first_tile.is_grass())
# Second tile is walkable stone and not dirt
second_tile = e.tile_at(Position(1, 0))
self.assertTrue(second_tile.is_walkable())
self.assertFalse(second_tile.is_dirt())
self.assertTrue(second_tile.is_stone())
# Last tile is walkable grass with dirt
last_tile = e.tile_at(Position(4, 1))
self.assertTrue(last_tile.is_walkable())
self.assertTrue(last_tile.is_dirt())
self.assertTrue(last_tile.is_grass())
def setUp(self):
self.__env = Environment()
self.__env.set_var_value('x', '10')
self.__env.set_var_value('var_name', 'kek')
class TestPreprocessor(unittest.TestCase):
def setUp(self):
self.__env = Environment()
self.__env.set_var_value('x', '10')
self.__env.set_var_value('var_name', 'kek')
def test_find_var(self):
var_name, rest = Preprocessor.find_var('var')
self.assertEqual(var_name, 'var')
self.assertEqual(rest, '')
def test_find_var_in_string(self):
var_name, rest = Preprocessor.find_var('var_1 567')
self.assertEqual(var_name, 'var_1')
self.assertEqual(rest, ' 567')
def test_substitute_vars_single(self):
result = Preprocessor.substitute_vars('$x', self.__env)
self.assertEqual('10',result)
def test_substitute_vars_in_single_quotes(self):
result = Preprocessor.substitute_vars('\'$x\'', self.__env)
self.assertEqual('$x', result)
def test_substitute_vars_in_double_quotes(self):
result = Preprocessor.substitute_vars('\"$x\"', self.__env)
self.assertEqual('10', result)
def test_substitute_vars_double_in_single_quotes(self):
result = Preprocessor.substitute_vars('\'$var_name\"$x\"kek\'', self.__env)
self.assertEqual('$var_name\"$x\"kek', result)
def test_substitute_vars_single_in_double_quotes(self):
result = Preprocessor.substitute_vars('\"$var_name\'$x\'kek\"', self.__env)
self.assertEqual('kek\'10\'kek', result)
def test_substitute_vars_single_in_single_quotes(self):
result = Preprocessor.substitute_vars('\'$var_name\'$x\'kek\'', self.__env)
self.assertEqual('$var_name10kek', result)
def test_substitute_vars_double_in_double_quotes(self):
result = Preprocessor.substitute_vars('\"$var_name\"$x\"kek\"', self.__env)
self.assertEqual('kek10kek', result)
def test_substitute_vars_single_quotes_in_text(self):
result = Preprocessor.substitute_vars('kek\'$var_name\'kek', self.__env)
self.assertEqual('kek$var_namekek', result)
def test_substitute_vars_double_quotes_in_text(self):
result = Preprocessor.substitute_vars('kek\"$var_name\"kek', self.__env)
self.assertEqual('kekkekkek', result)
def test_substitute_two_vars(self):
result = Preprocessor.substitute_vars('$x$var_name', self.__env)
self.assertEqual('10kek', result)
def test_substitute_two_vars_in_single_quotes(self):
result = Preprocessor.substitute_vars('\'$x$var_name\'', self.__env)
self.assertEqual('$x$var_name', result)
def test_substitute_two_vars_in_double_quotes(self):
result = Preprocessor.substitute_vars('\"$x$var_name\"', self.__env)
self.assertEqual('10kek', result)
def test_substitute_no_var_in_text_in_double_quotes(self):
result = Preprocessor.substitute_vars('\"kek$xl\"', self.__env)
self.assertEqual('kek', result)
def test_substitute_var_in_text_in_double_quotes(self):
result = Preprocessor.substitute_vars('\"kek$var_name 10\"', self.__env)
self.assertEqual('kekkek 10', result)
def test_substitute_var_in_three_double_quotes(self):
result = Preprocessor.substitute_vars('\"\"\"$var_name\"\"\"', self.__env)
self.assertEqual('kek', result)
def test_substitute_var_in_three_single_quotes(self):
result = Preprocessor.substitute_vars('\'\'\'$var_name\'\'\'', self.__env)
self.assertEqual('$var_name', result)
def test_exception_one_single_quote(self):
self.assertRaises(ParserException,
Preprocessor.substitute_vars, '\'xx', self.__env)
def test_exception_one_double_quote(self):
self.assertRaises(ParserException,
Preprocessor.substitute_vars, '\"xx', self.__env)
def test_exception_one_single_and_one_double_quote(self):
self.assertRaises(ParserException,
Preprocessor.substitute_vars, '\"x\'x', self.__env)
def bank__set_state_variables(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.set_state_variables \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test bank__set_state_variables in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
text = "Original state variables:"
print(text)
print(bank.get_state_variables())
text = "New state variables:"
print(text)
bank.set_state_variables({'test': 0.66})
print(bank.get_state_variables())
import logging
import pandas as pd
import numpy as np
import random
from src.frange import frange
import matplotlib.pyplot as plt
import sys
import decimal
# INITIALIZATION
#
environment_directory = str("configs/environment/")
identifier = str("firesales")
############
environment = Environment(environment_directory, identifier)
runner = Runner(environment)
############
#Declare variables of interest for the simulation
print("the illiquidity paramer is"), environment.static_parameters['illiquidity'] #is declared inside ENV config
print("the num_simulations paramer is"), environment.static_parameters['num_simulations'] # is declared inside ENV config
environment.static_parameters['leverage_increase'] = (1/3)
print environment.static_parameters['leverage_increase']
for i in range(int(environment.static_parameters['num_simulations'])):
if i == 0:
def bank__clear_accounts(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.clear_accounts \n"
text = text + " Checking if after the clear_accounts the total amount \n"
text = text + " of transactions in zero. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__clear_accounts in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.add_transaction("deposits", "", "test_household",
bank.identifier, 0.0, 0.09, 0, -1, environment)
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
for bank in environment.banks:
print(bank)
for firm in environment.firms:
print(firm)
for household in environment.households:
print(household)
bank.clear_accounts(environment)
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
def bank__check_consistency(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.check_consitency \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__check_consistency in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
print("Adding additional deposits without adding appropriate cash/loans.")
bank.add_transaction("deposits", "", environment.get_agent_by_id("test_household"),
bank, 150, bank.interest_rate_deposits, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
# -------------------------------------------------------------------------
#
# MAIN
#
# -------------------------------------------------------------------------
if __name__ == '__main__':
from src.environment import Environment
from src.runner import Runner
args = ["configs/environment/", "environment_config", "log/"]
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
environment = Environment(environment_directory, identifier)
runner = Runner(environment)
#
# UPDATE STEP
#
# for i in range(int(environment.static_parameters['num_simulations'])):
# environment.initialize(environment_directory, identifier)
# runner.initialize(environment)
# # do the run
# runner.do_run(environment)
def bank__add_transaction(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.add_transaction \n"
text = text + " The most simple way to test this function is to assign an new \n"
text = text + " transaction to our bank. Therefore, lets just assign the following \n"
text = text + " transaction and check whether it has been added: \n"
text = text + ' (type = "deposits", fromID = -1, toID = bank.identifier, amount = 10, \n'
text = text + " interest = 0.09, maturity = 0, timeOfDefault = -1) \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__add_transaction in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print(bank)
print("Adding new transaction: \n")
print(environment.get_agent_by_id(bank.identifier))
bank.add_transaction("deposits", "", "test_household",
bank.identifier, 10, 0.09, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print(bank)
def bank__check_consistency(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.check_consitency \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__check_consistency in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
print("Adding additional deposits without adding appropriate cash/loans.")
bank.add_transaction("deposits", "", environment.get_agent_by_id("test_household"),
bank, 150, bank.interest_rate_deposits, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
def begin_scope(self):
self.environment = Environment({}, self.environment)
return self.environment
sys.exit()
#
# INITIALIZATION
#
environment_directory = str(args[1])
identifier = str(args[2])
log_directory = str(args[3])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for run: %s', environment_directory + identifier + ".xml")
environment = Environment(environment_directory, identifier)
runner = Runner(environment)
#
# UPDATE STEP
#
for i in range(int(environment.num_simulations)):
logging.info(' STARTED with run %s', str(i))
environment.initialize(environment_directory, identifier)
runner.initialize(environment)
# do the run
runner.do_run(environment)
logging.info(' DONE')
#
# MEASUREMENT AND LOGGING
To test a trained agent on an environment from the carl/ directory run
python3 -m scripts.run_test
"""
import argparse
import os.path
from src.agent import DQLAgent
from src.circuit import Circuit
from src.environment import Environment
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--max_steps', type=int, default=200)
parser.add_argument('--gamma', type=float, default=1.0)
parser.add_argument('--model', type=str)
args = parser.parse_args()
agent = DQLAgent(gamma=args.gamma, max_steps=args.max_steps)
circuit = Circuit([(0, 0), (0.5, 1), (0, 2), (2, 2), (3, 1), (6, 2),
(6, 0)],
width=0.3)
env = Environment(circuit, render=True)
if agent.load(args.model):
name = os.path.basename(args.model)
agent.run_once(env, train=False, greedy=True, name=name[:-3])
print("{:.2f} laps in {} steps".format(
circuit.laps + circuit.progression, args.max_steps))
def test():
data = Data(cargs.min_size, cargs.max_size)
env = Environment(data.get_random_map(), cargs.show_screen, cargs.max_size)
agent = [Agent(env, args[0], 'agent_1'), Agent(env, args[1], 'agent_2')]
wl_mean, score_mean = [[deque(maxlen = 10000), deque(maxlen = 10000)] for _ in range(2)]
wl, score = [[deque(maxlen = 1000), deque(maxlen = 1000)] for _ in range(2)]
cnt_w, cnt_l = 0, 0
# agent[0].model.load_state_dict(torch.load(checkpoint_path_1, map_location = agent[0].model.device))
# agent[1].model.load_state_dict(torch.load(checkpoint_path_2, map_location = agent[1].model.device))
for _ep in range(cargs.n_epochs):
if _ep % 10 == 9:
print('Testing_epochs: {}'.format(_ep + 1))
done = False
start = time.time()
for _iter in count():
if cargs.show_screen:
env.render()
""" initialize """
actions, soft_state, soft_agent_pos = [[[], []] for i in range(3)]
""" update by step """
for i in range(env.num_players):
soft_state[i] = env.get_observation(i)
soft_agent_pos[i] = env.get_agent_pos(i)
""" select action for each agent """
for agent_id in range(env.n_agents):
for i in range(env.num_players):
agent_state = env.get_states_for_step(soft_state[i])
agent_step = env.get_agent_for_step(agent_id, soft_agent_pos[i])
act, log_p, state_val = agent[i].select_action(agent_state, agent_step)
soft_state[i] = env.soft_step_(agent_id, soft_state[i], act, soft_agent_pos[i])
actions[i].append(act)
# actions[1] = [np.random.randint(0, env.n_actions - 1) for _ in range(env.n_agents)]
# actions[1] = [0] * env.n_agents
# actions[1] = pred_acts[1]
next_state, final_reward, done, _ = env.step(actions[0], actions[1], cargs.show_screen)
if done:
score[0].append(env.players[0].total_score)
score[1].append(env.players[1].total_score)
if env.players[0].total_score > env.players[1].total_score:
cnt_w += 1
else:
cnt_l += 1
break
end = time.time()
wl[0].append(cnt_w)
wl[1].append(cnt_l)
for i in range(2):
wl_mean[i].append(np.mean(wl[i]))
score_mean[i].append(np.mean(score[i]))
if _ep % 50 == 49:
plot(wl_mean, vtype = 'Win')
plot(score_mean, vtype = 'Score')
print("Time: {0: >#.3f}s". format(1000*(end - start)))
env = Environment(data.get_random_map(), cargs.show_screen, cargs.max_size)
parser = argparse.ArgumentParser()
parser.add_argument("--num_episodes", type=int, default=1000)
parser.add_argument("--max_steps", type=int, default=200)
parser.add_argument("--minibatch_size", type=int, default=32)
parser.add_argument("--gamma", type=float, default=1.0)
parser.add_argument("--learning_rate", type=float, default=0.1)
parser.add_argument("--output", type=str, default="weights.h5")
parser.add_argument("--ui", type=str, default="true")
args = parser.parse_args()
circuit = Circuit([(0, 0), (0.5, 1), (0, 2), (2, 2), (3, 1), (6, 2),
(6, 0)],
width=0.3)
render = args.ui.lower() != "false"
env = Environment(circuit=circuit, render=render)
agent = DQLAgent(
state_size=len(env.current_state),
action_size=len(env.actions),
gamma=args.gamma,
learning_rate=args.learning_rate,
)
agent.train(
env,
episodes=args.num_episodes,
minibatch=args.minibatch_size,
output=args.output,
)
def create():
self.environment = Environment(settings, dummy_map)
return self.environment
def setUp(self):
self.env = Environment()
self.file = 'test_text.txt'
def main():
games = [
[[[10, 0], [9, 10]], [[8, 18], [9, 8]]],
[[[9, 0], [6, 8]], [[4, 13], [7, 5]]],
[[[8, 0], [7, 10]], [[6, 14], [7, 4]]],
[[[7, 0], [5, 9]], [[4, 11], [6, 2]]],
[[[7, 0], [4, 8]], [[2, 9], [5, 1]]],
[[[7, 1], [3, 8]], [[1, 7], [5, 0]]],
[[[10, 4], [9, 14]], [[12, 22], [9, 8]]],
[[[9, 3], [6, 11]], [[7, 16], [7, 5]]],
[[[8, 3], [7, 13]], [[9, 17], [7, 4]]],
[[[7, 2], [5, 11]], [[6, 13], [6, 2]]],
[[[7, 2], [4, 10]], [[4, 11], [5, 1]]],
[[[7, 3], [3, 10]], [[3, 9], [5, 0]]],
]
# add Bimatrix Games
env = Environment()
env.iterations = iterations
for game in games:
env.add_game(np.asarray(game))
if save:
n = 1
folder = os.path.join(os.getcwd(), "data", "game_histories")
directory = os.path.join(folder, str(n))
path = os.path.exists(directory)
while path:
n += 1
directory = os.path.join(folder, str(n))
path = os.path.exists(directory)
os.mkdir(directory)
print("saving directory: {}".format(directory))
if grid:
if exp_decay:
range_decay = (0.9999, 0.94)
else:
range_decay = (0.001, 0.01)
t_init = (0.5, 1.8)
t_final = (0.1, 1)
points_t_final = 3
points_t_init = intervals
points_decay = 1
a_range = (0.01, 0.65)
best_fit, parameter_space = grid_search(
t_init,
points_t_init,
a_range,
intervals,
range_decay,
points_decay,
t_final,
points_t_final,
env,
runs,
agents,
kwargs_agent={
"d_exp": d_exp,
"exponential_decay": exp_decay,
"strategy": strategy,
},
kwargs_averages={"begin": begin},
)
mse = best_fit["mse"]
print("Mean Squared Error {}".format(mse))
print("params {}".format(best_fit["params"]))
histories = best_fit["history"]
if save:
with open(os.path.join(directory, "config.pkl"), "wb") as f:
pickle.dump(best_fit, f, pickle.HIGHEST_PROTOCOL)
np.save(os.path.join(directory, "params.npy"), parameter_space)
print("history saved to {}".format(os.path.join(directory, "params.npy")))
open_results(directory)
if show_fig:
plot_average_run(histories, save_fig, directory)
plt.show()
elif simulate:
for _ in range(agents):
env.add_player(
Agent(
strategy=strategy,
t=t,
alpha=a,
player_type=0,
exponential_decay=exp_decay,
d_exp=d_exp,
decay_rate=decay_rate,
)
)
env.add_player(
Agent(
strategy=strategy,
t=t,
alpha=a,
player_type=1,
exponential_decay=exp_decay,
d_exp=d_exp,
decay_rate=decay_rate,
)
)
histories = []
for _ in range(runs):
history = env.play()
histories.append(history)
mse = mean_squared_error(histories)
print("MSD {}".format(mse))
if show_fig:
plot_average_run(histories, save_fig)
plt.show()
# save history
if save:
np.save(os.path.join(directory, "histories.npy"), histories)
print(
"history saved to {}".format(os.path.join(directory, "histories.npy"))
)
if save_fig:
directory = os.path.join(os.getcwd(), "figures")
if experimental:
plot_data()
if save:
return directory
def updater__accrue_interests(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.updater import Updater
text = "This test checks updater.accrue_interests \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test updater__accrue_interests in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
bank.interest_rate_deposits = 0.05
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
model = Updater(environment)
model.__init__(environment)
environment.new_transaction(
"deposits", "",
environment.get_agent_by_id("test_household").identifier,
environment.get_agent_by_id("test_bank"), 10.0,
environment.get_agent_by_id("test_bank").interest_rate_deposits, 0,
-1)
print(environment.get_agent_by_id("test_household"))
print("Accruing interests\n")
model.accrue_interests(environment, 0)
print(environment.get_agent_by_id("test_household"))
class TestParser(unittest.TestCase):
def setUp(self):
self.env = Environment()
self.env.set_var_value('x', '10')
self.env.set_var_value('t', 'text')
self.env.set_var_value('e', 'exit')
self.env.set_var_value('echo', 'echo')
self.env.set_var_value('p', 'pwd')
self.parser = Parser(self.env)
self.exseptions_lexemes = [
Lexeme('|', Lexeme_type.PIPE),
Lexeme('m=', Lexeme_type.ASSIGNMENT),
Lexeme('|', Lexeme_type.PIPE)
]
def test_echo(self):
lexems = [
Lexeme('$echo', Lexeme_type.VAR),
Lexeme('\'word\'', Lexeme_type.STRING_WITH_QUOTES),
Lexeme('\"word$x\"', Lexeme_type.STRING_WITH_QUOTES)
]
command = self.parser.build_command(lexems)
self.assertEqual(CommandECHO, type(command))
def test_wc(self):
lexems = [
Lexeme('wc', Lexeme_type.STRING),
Lexeme('test1.txt', Lexeme_type.STRING_WITH_QUOTES),
Lexeme('test2.txt', Lexeme_type.STRING_WITH_QUOTES),
Lexeme('test3.txt', Lexeme_type.STRING_WITH_QUOTES)
]
command = self.parser.build_command(lexems)
self.assertEqual(CommandWC, type(command))
def test_cat(self):
lexems = [
Lexeme('cat', Lexeme_type.STRING),
Lexeme('test.txt', Lexeme_type.STRING)
]
command = self.parser.build_command(lexems)
self.assertEqual(CommandCAT, type(command))
def test_pwd(self):
lexems = [
Lexeme('pwd', Lexeme_type.STRING),
Lexeme('$t$x', Lexeme_type.VAR)
]
command = self.parser.build_command(lexems)
self.assertEqual(CommandPWD, type(command))
def test_var(self):
lexems = [Lexeme('$e', Lexeme_type.VAR)]
self.assertRaises(ExitException, self.parser.build_command, lexems)
def test_assignment(self):
lexems = [Lexeme('m=$echo', Lexeme_type.ASSIGNMENT)]
command = self.parser.build_command(lexems)
self.assertEqual(CommandASSIGNMENT, type(command))
def test_unknown(self):
lexems = [
Lexeme('ls', Lexeme_type.STRING),
Lexeme('-la', Lexeme_type.STRING)
]
command = self.parser.build_command(lexems)
self.assertEqual(UnknownCommand, type(command))
def test_echo_pipe_cat(self):
lexems = [
Lexeme('$echo', Lexeme_type.VAR),
Lexeme('\"t\"', Lexeme_type.STRING_WITH_QUOTES),
Lexeme('|', Lexeme_type.PIPE),
Lexeme('cat', Lexeme_type.STRING)
]
command = self.parser.build_command(lexems)
self.assertEqual(CommandPIPE, type(command))
def test_echo_pipe_cat_pipe_pwd(self):
lexems = [
Lexeme('$echo', Lexeme_type.VAR),
Lexeme('\"t\"', Lexeme_type.STRING_WITH_QUOTES),
Lexeme('|', Lexeme_type.PIPE),
Lexeme('cat', Lexeme_type.STRING),
Lexeme('test_text.txt', Lexeme_type.STRING),
Lexeme('|', Lexeme_type.PIPE),
Lexeme('pwd', Lexeme_type.STRING)
]
command = self.parser.build_command(lexems)
self.assertEqual(CommandPIPE, type(command))
def test_exception_start_with_pipe(self):
self.assertRaises(ParserException, self.parser.build_command,
self.exseptions_lexemes)
def test_exception_assignment_without_value(self):
self.assertRaises(ParserException, self.parser.build_command,
self.exseptions_lexemes[1:])
def test_exception_ends_with_pipe(self):
self.assertRaises(ParserException, self.parser.build_command,
self.exseptions_lexemes[1:2])
def test_exception_bad_assignment(self):
self.assertRaises(ParserException, self.parser.build_command,
[Lexeme('$a=10', Lexeme_type.VAR)])
def bank__get_account(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_account \n"
text = text + " The purpose of this method is to establish an account for our bank which contains \n"
text = text + " all kinds of assets and liabilities. The method simply adds all kinds of assets \n"
text = text + " and stores them in one volume. As our Banks holds 250.0 assets \n"
text = text + " and 250 liabilites the total volume of our account should be 500.0 \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__get_account in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0 # counting all types in account together
print(bank) # and checking how much is the total
# volume of the account
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
account = account + bank.get_account(type)
print("D = " + str(account))
if type == "cash":
account = account + bank.get_account(type)
print("D+M = " + str(account))
if type == "loans":
account = account + bank.get_account(type)
print("D+M+L = " + str(account))
def bank__get_account_num_transactions(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_account_num_transactions \n"
text = text + " The purpose of this method is to count the numbers of transaction for \n"
text = text + " accounts banks hold. Our standard bank has 3 transactions by default. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__get_account_num_transactions in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
num_transactions = 0.0 # counting all types in account together
print(bank)
# and checking if the number of transaction
# is increasing by one
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D = " + str(num_transactions))
if type == "cash":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D+M = " + str(num_transactions))
if type == "loans":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D+M+L = " + str(num_transactions))
def bank__add_transaction(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.add_transaction \n"
text = text + " The most simple way to test this function is to assign an new \n"
text = text + " transaction to our bank. Therefore, lets just assign the following \n"
text = text + " transaction and check whether it has been added: \n"
text = text + ' (type = "deposits", fromID = -1, toID = bank.identifier, amount = 10, \n'
text = text + " interest = 0.09, maturity = 0, timeOfDefault = -1) \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__add_transaction in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print(bank)
print("Adding new transaction: \n")
print(environment.get_agent_by_id(bank.identifier))
bank.add_transaction("deposits", "", "test_household",
bank.identifier, 10, 0.09, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print(bank)
def test_mountain(self):
m2 = Mountain(10**3, 0, (50, 50))
t = Environment([m2])
t.export_heightmap("mountain_as_env.png", res_x=100, res_y=100)
def bank__purge_accounts(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.purge_accounts \n"
text = text + " Checking if after the purge_accounts the total amount \n"
text = text + " of transactions in the bank stays the same. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__purge_accounts in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.network.transactions.add_node(household.identifier)
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.network.transactions.add_node(firm.identifier)
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
environment.network.transactions.add_node(bank.identifier)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.add_transaction("deposits", "", environment.get_agent_by_id("test_household"),
bank.identifier, 0.0, 0.09, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.accounts[0].purge_accounts(environment)
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
import argparse
from src.environment import Environment
"""
Helper script for the Viper tool chain.
Runs tests, measures time and kills processes that take too long.
"""
def print_header():
print()
print("Viper tool chain runner")
print("-----------------------")
print()
print_header()
parser = argparse.ArgumentParser(description='Viper tool chain runner.')
parser.add_argument('config_file', help='the configuration file for this script.')
args = parser.parse_args()
env = Environment()
env.exec(args.config_file)
env.analyze()
def train():
data = Data(cargs.min_size, cargs.max_size)
env = Environment(data.get_random_map(), cargs.show_screen, cargs.max_size)
agent = [Agent(env, args[0], 'agent_1'), Agent(env, args[1], 'agent_2')]
wl_mean, score_mean, l_val_mean =\
[[deque(maxlen = 10000), deque(maxlen = 10000)] for _ in range(3)]
wl, score, l_val = [[deque(maxlen = 1000), deque(maxlen = 1000)] for _ in range(3)]
lr_super = [args[0].exp_rate, args[1].exp_rate]
cnt_w, cnt_l = 0, 0
# agent[0].model.load_state_dict(torch.load(checkpoint_path_1, map_location = agent[0].model.device))
# agent[1].model.load_state_dict(torch.load(checkpoint_path_2, map_location = agent[1].model.device))
for _ep in range(cargs.n_epochs):
if _ep % 10 == 9:
print('Training_epochs: {}'.format(_ep + 1))
for _game in range(cargs.n_games):
done = False
start = time.time()
for _iter in count():
if cargs.show_screen:
env.render()
""" initialize """
actions, state_vals, log_probs, rewards, soft_state, \
soft_agent_pos, pred_acts, exp_rewards = [[[], []] for i in range(8)]
""" update by step """
for i in range(env.num_players):
soft_state[i] = env.get_observation(i)
soft_agent_pos[i] = env.get_agent_pos(i)
pred_acts[i], exp_rewards[i] = agent[i].select_action_smart(soft_state[i], soft_agent_pos[i], env)
""" select action for each agent """
for agent_id in range(env.n_agents):
for i in range(env.num_players):
agent_state = env.get_states_for_step(soft_state[i])
# not change
agent_step = env.get_agent_for_step(agent_id, soft_agent_pos)
act, log_p, state_val = 0, 0, 0
if random.random() < lr_super[i]:
act, log_p, state_val = agent[i].select_action_by_exp(
agent_state, agent_step, pred_acts[i][agent_id])
else:
act, log_p, state_val = agent[i].select_action(agent_state, agent_step)
soft_state[i] = env.soft_step_(agent_id, soft_state[i], act, soft_agent_pos[i])
state_vals[i].append(state_val)
actions[i].append(act)
log_probs[i].append(log_p)
# actions[1] = [np.random.randint(0, env.n_actions - 1) for _ in range(env.n_agents)]
# actions[1] = [0] * env.n_agents
# actions[1] = pred_acts[1]
next_state, final_reward, done, _ = env.step(actions[0], actions[1], cargs.show_screen)
for i in range(env.n_agents):
rewards[0].append(final_reward)
rewards[1].append(- final_reward)
for j in range(env.num_players):
if pred_acts[j][i] == actions[j][i]:
reward = exp_rewards[j][i]
beta = 0.9
rewards[j][i] = rewards[j][i] * (1 - beta) + beta * reward
agent[j].model.store(log_probs[j][i], state_vals[j][i], rewards[j][i])
if done:
score[0].append(env.players[0].total_score)
score[1].append(env.players[1].total_score)
if env.players[0].total_score > env.players[1].total_score:
cnt_w += 1
else:
cnt_l += 1
break
agent[0].learn()
agent[1].learn()
end = time.time()
if _ep > 3:
l_val[0].append(agent[0].value_loss)
l_val[1].append(agent[1].value_loss)
wl[0].append(cnt_w)
wl[1].append(cnt_l)
for i in range(2):
wl_mean[i].append(np.mean(wl[i]))
score_mean[i].append(np.mean(score[i]))
l_val_mean[i].append(np.mean(l_val[i]))
env.soft_reset()
if _ep % 50 == 49:
if cargs.visualize:
plot(wl_mean, vtype = 'Win')
plot(score_mean, vtype = 'Score')
plot(l_val_mean, vtype = 'Loss_Value')
print("Time: {0: >#.3f}s". format(1000*(end - start)))
if args[0].saved_checkpoint:
agent[0].save_models()
# torch.save(agent[0].model.state_dict(), checkpoint_path_1)
if args[1].saved_checkpoint:
agent[1].save_models()
# torch.save(agent[1].model.state_dict(), checkpoint_path_2)
# print('Completed episodes')
# lr_super *= 0.999
env = Environment(data.get_random_map(), cargs.show_screen, cargs.max_size)
class TestUM(unittest.TestCase):
def setUp(self):
self.w1 = WeatherModel(1)
self.w2 = WeatherModel(2)
self.e1 = Environment(10,15)
self.e2 = Environment(20,25)
loc = [2, 1]
self.tile = self.e1.get_tile(loc)
self.teff1 = Teff(self.tile)
# self.d1 = Deer(self.tile)
def tearDown(self):
pass
# Weather Model Tests
def test_weatherModel_days_in_year(self):
self.assertEqual(self.w1.totalDays, 365, "Total days is incorrect")
self.assertEqual(self.w2.totalDays, 730, "Total days is incorrect")
def test_weatherModel_years(self):
self.assertEqual(self.w1.numYears, 1, "Number of years is incorrect")
self.assertEqual(self.w2.numYears, 2, "Number of years is incorrect")
def test_weatherModel_days_property(self):
self.assertEqual(self.w1.totalDays, len(self.w1.days), "Total days must equal length of day property")
def test_weatherModel_sunlight(self):
for i in range(0, self.w1.days.size):
self.assertLess(self.w1.days[i].sun, 24, "A day cannot have more than 24 hours of sunlight")
self.assertGreater(self.w1.days[0].sun, 0, "A day cannot have less than 0 hours of sunlight")
for i in range(0, self.w2.days.size):
self.assertLess(self.w2.days[i].sun, 24, "A day cannot have more than 24 hours of sunlight")
self.assertGreater(self.w2.days[0].sun, 0, "A day cannot have less than 0 hours of sunlight")
def test_weatherModel_precipitation(self):
for i in range(0, self.w1.days.size):
self.assertGreaterEqual(self.w1.days[0].rain, 0, "A day cannot have less than 0 inches of precipitation")
for i in range(0, self.w2.days.size):
self.assertGreaterEqual(self.w2.days[0].rain, 0, "A day cannot have less than 0 inches of precipitation")
# Environment Tests
def test_environment_width(self):
self.assertEqual(self.e1.width, 10, "Initial width for e1 is 10")
self.assertEqual(self.e2.width, 20, "Initial width for e2 is 20")
def test_environment_height(self):
self.assertEqual(self.e1.height, 15, "Initial height for e1 is 15")
self.assertEqual(self.e2.height, 25, "Initial height for e2 is 25")
def test_environment_teff_mass(self):
self.assertEqual(self.e1.teff_total_mass, 0, "Initial mass for e1 is 0")
self.assertEqual(self.e2.teff_total_mass, 0, "Initial mass for e2 is 0")
def test_environment_valid_location(self):
loc1 = [2,2]
self.assertEqual(self.e1.is_location_valid(loc1), True, "Location [2, 2] is valid")
self.assertEqual(self.e2.is_location_valid(loc1), True, "Location [2, 2] is valid")
loc2 = [-1, -1]
self.assertEqual(self.e1.is_location_valid(loc2), False, "Location [-1, -1] is invalid")
self.assertEqual(self.e2.is_location_valid(loc2), False, "Location [-1, -1] is invalid")
loc3 = [-1, 1]
self.assertEqual(self.e1.is_location_valid(loc3), False, "Location [-1, 1] is invalid")
self.assertEqual(self.e2.is_location_valid(loc3), False, "Location [-1, 1] is invalid")
loc4 = [1, -1]
self.assertEqual(self.e1.is_location_valid(loc4), False, "Location [1, -1] is invalid")
self.assertEqual(self.e2.is_location_valid(loc4), False, "Location [1, -1] is invalid")
loc5 = [40, 40]
self.assertEqual(self.e1.is_location_valid(loc5), False, "Location [40, 40] is invalid")
self.assertEqual(self.e2.is_location_valid(loc5), False, "Location [40, 40] is invalid")
def test_environment_distance(self):
loc1 = [0, 1]
loc2 = [0, 2]
loc3 = [0, 3]
loc4 = [-1, 1]
loc5 = [1, 2]
self.assertEqual(self.e1.get_distance(loc1, loc2), 1, "Distance is one")
self.assertEqual(self.e2.get_distance(loc1, loc2), 1, "Distance is one")
self.assertEqual(self.e1.get_distance(loc1, loc3), 2, "Distance is two")
self.assertEqual(self.e2.get_distance(loc1, loc3), 2, "Distance is two")
self.assertEqual(self.e1.get_distance(loc1, loc4), 1, "Distance is one")
self.assertEqual(self.e2.get_distance(loc1, loc4), 1, "Distance is one")
self.assertEqual(self.e1.get_distance(loc1, loc5), math.sqrt(2), "Distance is square root of two")
self.assertEqual(self.e2.get_distance(loc1, loc5), math.sqrt(2), "Distance is square root of two")
self.assertEqual(self.e1.get_distance(loc2, loc1), 1, "Distance is one")
self.assertEqual(self.e2.get_distance(loc2, loc1), 1, "Distance is one")
self.assertEqual(self.e1.get_distance(loc3, loc1), 2, "Distance is two")
self.assertEqual(self.e2.get_distance(loc3, loc1), 2, "Distance is two")
self.assertEqual(self.e1.get_distance(loc4, loc1), 1, "Distance is one")
self.assertEqual(self.e2.get_distance(loc4, loc1), 1, "Distance is one")
self.assertEqual(self.e1.get_distance(loc5, loc1), math.sqrt(2), "Distance is square root of two")
self.assertEqual(self.e2.get_distance(loc5, loc1), math.sqrt(2), "Distance is square root of two")
def test_environment_tile_location(self):
loc1 = [2, 1]
t1 = self.e1.get_tile(loc1)
t2 = self.e2.get_tile(loc1)
self.assertEqual(t1.tile_x, 2, "X coordinate is 2")
self.assertEqual(t1.tile_y, 1, "Y coordinate is 1")
self.assertEqual(t2.tile_x, 2, "X coordinate is 2")
self.assertEqual(t2.tile_y, 1, "Y coordinate is 1")
loc2 = [-1 ,1]
t3 = self.e1.get_tile(loc2)
t4 = self.e2.get_tile(loc2)
self.assertEqual(t3, None, "-1 is and invalid x coordinate")
self.assertEqual(t4, None, "-1 is and invalid x coordinate")
# Teff tests
def test_teff_initial_weight(self):
self.assertEqual(self.teff1.current_weight, 167, "Initial weight is 167 pounds")
self.assertEqual(self.teff1.get_amount(), 167, "Initial weight is 167 pounds")
# def test_teff_weight_change(self):
# newWeight = 10
# self.teff1.set_weight(newWeight)
#
# self.assertEqual(self.teff1.current_weight, newWeight, "Weight must be updated by set_weight method")
#
# self.teff1.set_weight(-1)
#
# self.assertEqual(self.teff1.current_weight, newWeight, "Weight cannot be updated to be negative")
# self.assertNotEqual(self.teff1.current_weight, -1, "Weight cannot be negative")
def test_teff_update(self):
self.teff1.updates = False
self.assertEqual(self.teff1.update(), None, "Updates is set to false")
# Deer Tests
def test_deer_initial_weight(self):
self.assertLess(self.d1.weight, 300, "Starting weight must be less than 300 pounds")
self.assertGreaterEqual(self.d1.weight, 110,
"Starting weight must be greater or equal to 110 pounds")
def test_deer_starve(self):
self.assertEqual(self.d1.state, State.alive, "Deer should be alive")
self.d1.weight = self.d1.max_weight * 0.6
self.d1.check_starve()
self.assertEqual(self.d1.state, State.dead, "Deer should die once it's weight is below 70% of it's max weight")
self.d1.weight = self.d1.max_weight
self.d1.check_starve()
self.assertEqual(self.d1.state, State.dead, "Animal state should not change from dead to alive")
# Tile Tests
def test_tile_location(self):
self.assertEqual(self.tile.tile_x, 2, "Tile's x location is set to 2 in set up method")
self.assertEqual(self.tile.tile_y, 1, "Tile's y location is set to 1 in set up method")
def test_tile_add_agent(self):
preAgents = len(self.tile.agent_mapping)
self.tile.add_agent(self.d1)
postAgents = len(self.tile.agent_mapping)
self.assertGreater(postAgents, preAgents,
"Adding an agent to a tile should increase agent_mapping")
def test_tile_weight_changed(self):
s = Soil(1, self.tile)
preWeight = self.tile.get_mass_and_totals()
self.tile.weight_changed(type(s), 10)
postWeight = self.tile.get_mass_and_totals()
self.assertNotEqual(preWeight,postWeight, "Adding weight should change total mass")
import argparse
from src.environment import Environment
"""
Helper script for the Viper tool chain.
Runs tests, measures time and kills processes that take too long.
"""
def print_header():
print()
print("Viper tool chain runner")
print("-----------------------")
print()
print_header()
parser = argparse.ArgumentParser(description='Viper tool chain runner.')
parser.add_argument('config_file',
help='the configuration file for this script.')
args = parser.parse_args()
env = Environment()
env.exec(args.config_file)
env.analyze()
from argparse import ArgumentParser
from src.agents import TDAgent, KPlyAgent, HumanAgent
from src.environment import Environment
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument('--export_dir')
parser.add_argument('--sign',
type=int,
choices=[-1, 1],
default=1,
required=False)
parser.add_argument('--k', type=int, default=1, required=False)
args = parser.parse_args()
print(args)
sgn = args.sign
human = HumanAgent(sign=sgn)
opponent = TDAgent.from_saved_model(sign=-sgn, export_dir=args.export_dir)
opponent = KPlyAgent(sign=-sgn, k=args.k, agent=opponent)
agents = [human, opponent]
env = Environment(agents)
env.play(verbose=True)
def test():
data = Data(cargs.min_size, cargs.max_size)
env = Environment(data.get_random_map(), cargs.show_screen, cargs.max_size)
agent = [Agent(env, args[0]), Agent(env, args[1])]
wl_mean, score_mean = [[deque(maxlen=10000),
deque(maxlen=10000)] for _ in range(2)]
wl, score = [[deque(maxlen=1000), deque(maxlen=1000)] for _ in range(2)]
cnt_w, cnt_l = 0, 0
exp_rate = [args[0].exp_rate, args[1].exp_rate]
# agent[0].model.load_state_dict(torch.load(checkpoint_path_1, map_location = agent[0].model.device))
# agent[1].model.load_state_dict(torch.load(checkpoint_path_2, map_location = agent[1].model.device))
for _ep in range(cargs.n_epochs):
if _ep % 10 == 9:
print('Testing_epochs: {}'.format(_ep + 1))
done = False
start = time.time()
current_state = env.get_observation(0)
for _iter in range(env.n_turns):
if cargs.show_screen:
env.render()
""" initialize """
actions, soft_state, soft_agent_pos, pred_acts, exp_rewards = \
[[[], []] for i in range(5)]
""" update by step """
for i in range(env.num_players):
soft_state[i] = env.get_observation(i)
soft_agent_pos[i] = env.get_agent_pos(i)
pred_acts[i], exp_rewards[i] = agent[i].select_action_smart(
soft_state[i], soft_agent_pos[i], env)
""" select action for each agent """
for agent_id in range(env.n_agents):
for i in range(env.num_players):
''' get state to forward '''
state_step = env.get_states_for_step(current_state)
agent_step = env.get_agent_for_step(
agent_id, i, soft_agent_pos)
''' predict from model'''
if random.random() < exp_rate[i]:
act = pred_acts[i][agent_id]
else:
# print(i)
act = agent[i].get_action(state_step, agent_step)
# act, _, _ = agent[i].select_action(state_step, agent_step)
''' convert state to opponent state '''
env.convert_to_opn_obs(current_state, soft_agent_pos)
''' storage infomation trainning'''
actions[i].append(act)
''' last action to fit next state '''
acts = [actions[0][-1], actions[1][-1]]
current_state, temp_rewards = env.soft_step_2(
agent_id, current_state, acts, soft_agent_pos)
# actions[1] = [np.random.randint(0, env.n_actions - 1) for _ in range(env.n_agents)]
# actions[1] = [0] * env.n_agents
# actions[1] = pred_acts[1]
current_state, final_reward, done, _ = env.step(
actions[0], actions[1], cargs.show_screen)
if done:
score[0].append(env.players[0].total_score)
score[1].append(env.players[1].total_score)
if env.players[0].total_score > env.players[1].total_score:
cnt_w += 1
else:
cnt_l += 1
break
end = time.time()
wl[0].append(cnt_w)
wl[1].append(cnt_l)
for i in range(2):
wl_mean[i].append(np.mean(wl[i]))
score_mean[i].append(np.mean(score[i]))
if _ep % 50 == 49:
plot(wl_mean, vtype='Win')
plot(score_mean, vtype='Score')
print("Time: {0: >#.3f}s".format(1000 * (end - start)))
env.soft_reset()
def central_bank__get_account_num_transactions(self, args):
import os
from src.bank import Bank
from src.central_bank import CentralBank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks central_bank.get_account_num_transactions \n"
text = text + " The purpose of this method is to count the numbers of transaction for \n"
text = text + " accounts banks hold. Our central bank has 3 transactions by default. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test central_bank__get_account_num_transactions in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a central bank
cb = CentralBank()
cb.identifier = "test_central_bank"
environment.central_bank.append(cb)
#
# TESTING
#
environment.new_transaction("deposits", "", cb.identifier, "test_firm",
100, 0.0, 0, -1)
environment.new_transaction("cash", "", cb.identifier, "test_firm",
200, 0.0, 0, -1)
environment.new_transaction("loans", "", cb.identifier, "test_firm",
300, 0.0, 0, -1)
num_transactions = 0.0 # counting all types in account together
print(cb)
# and checking if the number of transaction
# is increasing by one
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
num_transactions = num_transactions + cb.get_account_num_transactions(type)
print("D = " + str(num_transactions))
if type == "cash":
num_transactions = num_transactions + cb.get_account_num_transactions(type)
print("D+M = " + str(num_transactions))
if type == "loans":
num_transactions = num_transactions + cb.get_account_num_transactions(type)
print("D+M+L = " + str(num_transactions))
