def test_register_return_trip(self):
''' '''
params = Parameters(args=['2018-10-01'])
params.parse()
self.assertEqual(register_return_trip(params=params), None)
logging.info('Test passed for: register_return_trip')
def test_register_ride(self):
''' '''
params = Parameters(args=['Odense', 'Copenhagen', '2018-10-01', '4'])
params.parse()
self.assertEqual(register_ride(params=params), None)
logging.info('Test passed for: register_ride')
def register_return_trip(params: Parameters) -> bool:
''' Register return-ride in DB.'''
logging.info('Create return-trip.')
last_ride = RidesTable.get_last_inserted()
params.from_city = last_ride.to_city
params.to_city = last_ride.from_city
params.num_seats = last_ride.num_seats
register_ride(params=params)
def test_retrieve_rides(self):
''' '''
args = [
[Parameters(args=[]),
f'Odense Copenhagen 2018-10-01 4 {linesep}'], # S
[
Parameters(args=['2018-10-01']),
f'Odense Copenhagen 2018-10-01 4 {linesep}'
], # S 2018-10-01
[
Parameters(args=['2018-10-01', '4']),
f'Odense Copenhagen 2018-10-01 4 {linesep}'
], # S 2018-10-01 4
[Parameters(args=['2018-10-01', '7']), ''], # S 2018-10-01 7
[
Parameters(args=['2018-10-01', '2', 'Odense']),
f'Odense Copenhagen 2018-10-01 4 {linesep}'
], # S Odense 2018-10-01 2
[Parameters(args=['2018-10-01', 'Aarhus']),
''], # S 2018-10-01 Aarhus
[Parameters(args=['2020-10-01', 'Aarhus']),
''], # S 2020-10-01 Aarhus
[Parameters(args=['2020-10-01', 'Odense']),
''] # S 2020-10-01 Odense
]
for arg in args:
arg[0].parse()
self.assertEqual(retrieve_rides(arg[0]), arg[1])
logging.info('Test passed for: retrieve_rides')
def load_parametry(alpha: int = 4) -> Parameters:
temp_employee_number = 0
rating = []
skills_matrix = []
employee_time = []
company_time = []
population_size = 0
f = open("parametry.txt", "r")
f_lines = f.readlines()
for i in range(len(f_lines)):
if f_lines[i] == 'EMPLOYEE_NUMBER' + '\n':
temp_employee_number = int(f_lines[i + 1])
if f_lines[i] == 'POPULATION_NUMBER' + '\n':
population_size = int(f_lines[i + 1])
if f_lines[i] == 'RATING' + '\n':
rating = line2list(f_lines[i + 1])
if f_lines[i] == 'SKILLS_MATRIX' + '\n':
for j in range(temp_employee_number):
skills_matrix.append(line2list(f_lines[i + 1 + j]))
if f_lines[i] == 'EMPLOYEE_TIME' + '\n':
employee_time = line2list(f_lines[i + 1])
if f_lines[i] == 'COMPANY_TIME' + '\n':
company_time = line2list(f_lines[i + 1])
f.close()
return Parameters(rating,
skills_matrix,
employee_time,
company_time,
alpha=alpha,
population_count=population_size)
def handle_request(req: str):
''' Handles user requests.'''
cmd_list = req.split(' ')
cmd = cmd_list[0] # Get the cmd indicator, [S, C, R].
cmd_list.pop(0) # Remove cmd indicator.
args = cmd_list[:] # Make a new list, to reset indexing.
params = Parameters(args=args)
params.parse()
# Create ride.
if cmd in CMDs.create_ride:
try:
register_ride(params=params)
except Exception as e:
logging.error(
f'Registering trip failed: {e}'
)
# Retrieve ride(s).
elif cmd in CMDs.retrieve_ride:
try:
res = retrieve_rides(params=params)
print_out(txt=res)
except Exception as e:
logging.error(
f'Retreiving data failed: {e}'
)
# Create return ride.
elif cmd in CMDs.create_return_ride:
try:
register_return_trip(params=params)
except Exception as e:
logging.error(
f'Registering return trip failed: {e}'
)
def trian_model(args, model_path=None):
loader, num_words, embedding_matrix = create_new_data_loader(args)
parameters = Parameters(num_of_words=num_words, use_cuda=args.use_cuda)
cur_avb = AVB(params=parameters, embedding_matrix=embedding_matrix,
noise_size=args.noise_size)
curr_discriminator = Discriminator(params=parameters)
if args.use_cuda:
cur_avb = cur_avb.cuda()
curr_discriminator = curr_discriminator.cuda()
optimizer_vae = Adam(cur_avb.learnable_parameters(), args.learning_rate)
optimizer_discriminator = Adam(curr_discriminator.parameters(), args.learning_rate)
current_trainer = cur_avb.trainer(optimizer_vae=optimizer_vae,
discriminator=curr_discriminator,
optimizer_discriminator=optimizer_discriminator,
use_cuda=args.use_cuda,
dropout=args.dropout)
current_validator = cur_avb.validater(use_cuda=args.use_cuda, dropout=args.dropout)
valid_loader, _, _ = create_new_data_loader(args, path='data/nips_valid_sorted.txt')
if model_path:
check_point = torch.load(model_path)
cur_avb.load_state_dict(check_point['vae_state_dict'])
curr_discriminator.load_state_dict(check_point['discriminator_state_dict'])
optimizer_vae.load_state_dict(check_point['optimizer_vae'])
optimizer_discriminator.load_state_dict(check_point['optimizer_discriminator'])
epoch = 0
for iteration in range(args.num_iterations):
for data_tuple in loader:
kld, loss, d_cost, wasserstein_d = current_trainer(data_tuple=data_tuple)
if epoch % 15 == 14:
ppl_list = []
for valid_data_batch in valid_loader:
perplexity = current_validator(valid_data_batch)
print(perplexity)
ppl_list.append(perplexity)
print(np.average(ppl_list))
if epoch % 100 == 99:
save_checkpoint({
'epoch': iteration + 1,
'vae_state_dict': cur_avb.state_dict(),
'discriminator_state_dict': curr_discriminator.state_dict(),
'optimizer_vae': optimizer_vae.state_dict(),
'optimizer_discriminator': optimizer_discriminator.state_dict()
})
epoch += 1
def test_solution_functions(self):
rating1 = [3, 2, 1, 3]
skill1 = [[1, 1, 2, 2], [2, 1, 1, 2], [1, 1, 2, 1]]
sol1 = [2, 2, 0, 0]
solution1 = Solution(employee_number=3,
company_number=len(sol1),
premade_list=sol1)
self.assertEqual(solution1.f_target(rating1, skill1), 13)
emp_time = [1.5, 2, 1]
comp_time = [1, 1, 0.5, 0.5]
parameters = Parameters(rating1, skill1, emp_time, comp_time)
self.assertEqual(solution1.f_penalty(emp_time, comp_time), 4)
self.assertEqual(solution1.adaptation(parameters), 9)
def __init__(self, corpus_name, rarity=5):
"""Initialize parameters using a corpus
Parameters q (transition) and e (emission) are calculated by eponymous
functions from the class Parameters using counts over the corpus.
See parameters_class.py for details.
The corpus must be from the Penn WSJ treebank
corpus_name can be one of three names:
"train" uses /Users/ischeinfeld/Documents/Code/WSJ/train.txt
"develop" uses /Users/ischeinfeld/Documents/Code/WSJ/develop.txt"
"test" uses /Users/ischeinfeld/Documents/Code/WSJ/test.txt"
or corpus_name can be a complete path to the corpus text:
ex. /dir/dir/dir/file(.txt)
"""
### Create instance of Parameters with the given corpus
# Note that this completes all the counts for q and e
self.corpus = import_wsj(corpus_name)
self.params = Parameters(self.corpus)
def set_up(self, data_settings, params):
self.params_dict = params # object Runner的method: set_up
# time some things, like epoch time
start_time = time.time()
# ---------------------------------------- #
# DEFINE XVAL DATASETS #
# ---------------------------------------- #
# Create self.dataset_pair: DatasetPair containing train and val Datasets.
self._prepare_data(data_settings)
# Number of instances to put in a training batch.
self.n_batch = min(self.params_dict['n_batch'],
self.dataset_pair.n_train) # 如果训练集样本个数小于一个batch中的样本个数的话 就整个训练样本一起训练了
# This is already a model object because of the use of "!!python/object:... in the yaml file.
model = self.params_dict["model"]
# Set various attributes of the model
model.init_with_params(self.params_dict, self.procdata)
# Import priors from YAML
parameters = Parameters() # instantiate a class
parameters.load(self.params_dict)
print("----------------------------------------------")
if self.args.verbose:
print("parameters:")
parameters.pretty_print()
n_vals = LocalAndGlobal.from_list(
parameters.get_parameter_counts()) # (10,0,0,4), 有14个属性，分别记录着constant,global,global_conditioned,local parameters的维度
self.n_theta = n_vals.sum() # 所有parameters的个数 总共14个parameters
# Pytorch PARTS #
# DEFINE THE OBJECTIVE
print("Set up model")
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
#device = torch.device('cpu')
self.device = device
# create feed dictionaries for training dataset and validation dataset respectively
self._create_feed_dicts()
self.objective = Objective(parameters, self.params_dict, model, self.dataset_pair.times, self.procdata, self.device, self.args.dreg )#, self.args.verbose)
# Initialize the weight of neural networks
self.weight_orthogonal_initialization()
# feed the model to the GPU (if GPU is available)
self.objective.to(device)
self.optimizer = torch.optim.Adam(self.objective.parameters(), lr=5e-3)
def test_model(args):
model_path = "/home/tristan/Documents/pattern_recognition_final/resultscheckpoint_ecpch21.tar"
check_point = torch.load(model_path)
loader, num_words, embedding_matrix = create_new_data_loader(args)
parameters = Parameters(num_of_words=num_words, use_cuda=args.use_cuda)
cur_avb = AVB(params=parameters, embedding_matrix=embedding_matrix,
noise_size=args.noise_size)
if args.use_cuda:
cur_avb = cur_avb.cuda()
cur_avb.load_state_dict(check_point['vae_state_dict'])
validater = cur_avb.validater(data_loader=loader)
validater(use_cuda=args.use_cuda,
dropout=args.dropout)
def test_population_init(self):
rating1 = [1, 2, 3.5, 4, 5] # 5 firm
skill1 = [[2, 2, 1, 3, 2], [1, 1, 1, 2, 1], [2, 3, 2, 1,
1]] # 3 pracowników
emp_time1 = [1.8, 2, 0.7]
comp_time1 = [1, 2, 2.5, 1.5, 0.8]
params = Parameters(rating=rating1,
skills_matrix=skill1,
employee_time=emp_time1,
company_time=comp_time1)
current_population = Population(parameters=params)
self.assertEqual(len(current_population.main_list), 10)
custom_list = [
Solution(employee_number=len(params.skills_matrix),
company_number=len(params.skills_matrix[0]))
for i in range(5)
]
with self.assertRaises(MeasuresError):
Population(parameters=params, test_list=custom_list)
def train_model(args, model_path=None, save=True):
loader, num_words, embedding_matrix = create_new_data_loader(args)
valid_loader, _, _ = create_new_data_loader(
args, path='data/nips_valid_sorted.txt')
parameters = Parameters(num_of_words=num_words, use_cuda=args.use_cuda)
rvae = RVAE_dilated(params=parameters, embedding_matrix=embedding_matrix)
adam_optimizer = Adam(rvae.learnable_parameters(), args.learning_rate)
if args.use_cuda:
rvae = rvae.cuda()
if model_path:
check_point = torch.load(model_path)
rvae.load_state_dict(check_point['state_dict'])
adam_optimizer.load_state_dict(check_point['optimizer'])
current_trainer = rvae.trainer(optimizer=adam_optimizer,
use_cuda=args.use_cuda,
dropout=args.dropout)
current_validater = rvae.validater(use_cuda=args.use_cuda,
dropout=args.dropout)
epoch = 0
for train_data_batch in loader:
ppl_list = []
kld, loss = current_trainer(data_tuple=train_data_batch)
if epoch % 15 == 14:
for valid_data_batch in valid_loader:
perplexity = current_validater(valid_data_batch)
ppl_list.append(perplexity)
print(np.average(ppl_list))
epoch += 1
if save and epoch % 100 == 99:
save_checkpoint({
'epoch': epoch + 1,
'state_dict': rvae.state_dict(),
'optimizer': adam_optimizer.state_dict(),
})
def __init__(self, corpus_name, rarity=5): """Initialize parameters using a corpus Parameters q (transition) and e (emission) are calculated by eponymous functions from the class Parameters using counts over the corpus. See parameters_class.py for details. The corpus must be from the Penn WSJ treebank corpus_name can be one of three names: "train" uses /Users/ischeinfeld/Documents/Code/WSJ/train.txt "develop" uses /Users/ischeinfeld/Documents/Code/WSJ/develop.txt" "test" uses /Users/ischeinfeld/Documents/Code/WSJ/test.txt" or corpus_name can be a complete path to the corpus text: ex. /dir/dir/dir/file(.txt) """ ### Create instance of Parameters with the given corpus # Note that this completes all the counts for q and e self.corpus = import_wsj(corpus_name) self.params = Parameters(self.corpus)
def __init__(self, experiment: str, scenario: str, run: str):
self.cdi_map = {
'SUSCEPTIBLE': 'Susceptible',
'COLONIZED': 'Asymptomatically Colonized',
'CDI': 'CDI',
'DEAD': 'Dead'
}
self.experiment_dir = Path(experiment)
self.output_dir = Path(experiment, scenario, run, 'model_output')
self.params = Parameters(
Path(experiment, scenario, run, "parameters.json"))
self.daily_counts = pd.read_csv(
Path(self.output_dir, 'daily_counts.csv'))
self.locations = NcLocations(self.experiment_dir)
if 'cdi' == self.params.base['disease_model']:
self.cdi_cases = pd.read_csv(Path(self.output_dir,
'CDI_cases.csv'))
if 'cre' == self.params.base['disease_model']:
self.cre_cases = pd.read_csv(Path(self.output_dir,
'CRE_cases.csv'))
# ---- Some files may be compressed
try:
self.events = pd.read_csv(Path(self.output_dir,
'model_events.csv'))
except UnicodeDecodeError:
self.events = pd.read_csv(Path(self.output_dir,
'model_events.csv'),
compression='gzip')
self.catchment_counties =\
[1, 21, 23, 27, 35, 37, 49, 51, 57, 61, 63, 65, 67, 69, 79, 81, 83, 85, 89, 101, 103, 105, 107, 125, 127,
129, 133, 135, 145, 147, 149, 151, 155, 161, 163, 175, 183, 189, 191, 193, 195]
def setUp(self):
parameters = Parameters()
parameters.STRENGTH_THRESHOLD = STRENGTH_THRESHOLD
self.strategy = Strategy(None, parameters)
if optimisation_type == 'AD':
if set_of_angles is np.array([-45, 0, 45, 90], int):
lampam_to_be_optimised = np.array(
[1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0])
else:
lampam_to_be_optimised = np.array(
[1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1])
# Lamination parameters sensitivities from the first-lebel optimiser
first_level_sensitivities = np.ones((12, ), float)
parameters = Parameters(
constraints=constraints,
p_A=p_A,
n_D1=n_D1,
n_D2=n_D2,
n_D3=n_D3,
first_level_sensitivities=first_level_sensitivities,
lampam_to_be_optimised=lampam_to_be_optimised,
repair_membrane_switch=repair_membrane_switch,
repair_flexural_switch=repair_flexural_switch)
ss, completed, n_obj_func_D_calls = repair_ss(ss,
constraints,
parameters,
lampam_target,
count_obj=True)
print('Repair successful?', completed)
print_ss(ss, 20)
print('n_obj_func_D_calls', n_obj_func_D_calls)
check_ss_manufacturability(ss, constraints)
import src.hlt as hlt
from src.strategy import Strategy
from src.hlt import NORTH, EAST, SOUTH, WEST, STILL, Move, Square
from src.parameters import Parameters
import random
myID, game_map = hlt.get_init()
hlt.send_init("Level 3")
params = Parameters()
while True:
game_map.get_frame()
strategy = Strategy(game_map, params)
moves = [
strategy.decide_move(square) for square in game_map
if square.owner == myID
]
hlt.send_frame(moves)
table_param = pd.DataFrame()
table_param.loc[0, 'in_plane_coeffs'] \
= ' '.join(np.array(in_plane_coeffs, dtype=str))
table_param.loc[0, 'out_of_plane_coeffs'] \
= ' '.join(np.array(out_of_plane_coeffs, dtype=str))
table_param.loc[0, 'p_A'] = p_A
table_param.loc[0, 'n_D1'] = n_D1
table_param.loc[0, 'n_D2'] = n_D2
table_param.loc[0, 'n_D3'] = n_D3
table_param = table_param.transpose()
parameters = Parameters(
constraints=constraints,
p_A=p_A,
n_D1=n_D1,
n_D2=n_D2,
n_D3=n_D3,
repair_membrane_switch=True,
repair_flexural_switch=True)
#==============================================================================
# Tests
#==============================================================================
table_10_bal = pd.DataFrame()
table_membrane = pd.DataFrame()
table_diso_contig = pd.DataFrame()
table_flexural = pd.DataFrame()
data = pd.read_excel(file_to_open, sheet_name='stacks', index_col=0)
#print(data)
t_cummul_10_bal = 0
class Decoder:
def __init__(self, corpus_name, rarity=5):
"""Initialize parameters using a corpus
Parameters q (transition) and e (emission) are calculated by eponymous
functions from the class Parameters using counts over the corpus.
See parameters_class.py for details.
The corpus must be from the Penn WSJ treebank
corpus_name can be one of three names:
"train" uses /Users/ischeinfeld/Documents/Code/WSJ/train.txt
"develop" uses /Users/ischeinfeld/Documents/Code/WSJ/develop.txt"
"test" uses /Users/ischeinfeld/Documents/Code/WSJ/test.txt"
or corpus_name can be a complete path to the corpus text:
ex. /dir/dir/dir/file(.txt)
"""
### Create instance of Parameters with the given corpus
# Note that this completes all the counts for q and e
self.corpus = import_wsj(corpus_name)
self.params = Parameters(self.corpus)
def decode(self, sentence):
"""Decode a sentence
Input: a sentence (str)
Output: a tuple with lists of tokens and tags
"""
if isinstance(sentence, str):
token_seq = self.prep_sentence(sentence) # Tokenize sentence
#print("decoder_class_log, token_seq from string", token_seq)
else:
token_seq = sentence[0] # Already tokenized
#print("decoder_class_log, token_seq from list", token_seq)
for i in range(len(token_seq)): # Replace rare words
token_seq[i] = self.params.rep_rare_input(token_seq[i])
print("Token sequence after replacing rarities:", token_seq)
### Calculate pi values (log probabilities) and store back pointers
pi = []
bp = []
tags = self.params.tags
pi.append({})
pi[0]['<START>'] = {}
pi[0]['<START>']['<START>'] = 0 # pi[k][u][v] = 0 because log1 = 0
bp.append({})
bp[0]['<START>'] = {}
bp[0]['<START>']['<START>'] = None # pi[k][u][v]
for k in range(1, len(token_seq) + 1):
pi.append({}) # pi[k] = {}
bp.append({}) # bp[k] = {}
for u in tags:
pi[k][u] = {}
bp[k][u] = {}
for v in tags:
max = float('-inf')
pi[k][u][v] = max # Pi value
bp[k][u][v] = None # back pointer value
for w in pi[k - 1].keys():
try:
print("marker")
log_prob = (
pi[k - 1][w][u] + log(self.params.q(v, w, u)) +
log(self.params.e(token_seq[k - 1], v)))
# token_seq[k-1] is the token at v
except KeyError:
log_prob = float('-inf')
except ValueError:
log_prob = float('-inf')
if log_prob >= max: # Explicit
max = log_prob
pi[k][u][v] = log_prob # New max log probability
bp[k][u][v] = w # Backpointer to w
### Find last two tags, using <STOP> transition probability
max = float('-inf')
for u in tags:
for v in tags:
try:
log_prob = (pi[len(token_seq)][u][v] +
log(self.params.q('<STOP>', u, v)))
except KeyError:
log_prob = float('-inf')
except ValueError:
log_prob = float('-inf')
if log_prob >= max: # Explicit
max = log_prob
yn, yn_1 = v, u # | yn is y sub n | yn_1 is y sub (n-1)
### Get tag sequence using backtracking
tag_seq = [] # Replace with ['<START>', '<START>'] if desired
for word in token_seq:
tag_seq.append(None)
tag_seq[-1] = yn
tag_seq[-2] = yn_1
for i in range(len(tag_seq) - 3, -1, -1):
tag_seq[i] = bp[i + 3][tag_seq[i + 1]][tag_seq[i + 2]]
print("Log probability is:", max)
print("Probability is:", exp(max))
return (token_seq, tag_seq)
def prep_sentence(self, sentence):
"""Tokenizes a sentence string"""
sentence_list = TreebankWordTokenizer().tokenize(sentence)
return sentence_list
class Environment(object):
#
# VARIABLES
#
identifier = ""
parameters = Parameters()
state = State()
banks = []
network = Network("")
#
# METHODS
#
# -------------------------------------------------------------------------
# __init__
# -------------------------------------------------------------------------
def __init__(self):
pass
# -------------------------------------------------------------------------
# initialize
# -------------------------------------------------------------------------
def initialize(self, environment_directory, identifier):
self.identifier = identifier
# first, read in the environment file
environment_filename = environment_directory + identifier + ".xml"
self.read_environment_file(environment_filename)
logging.info(" environment file read: %s", environment_filename)
# then read in all the banks
if (self.parameters.bankDirectory != ""):
# print("oooo", self.parameters.bankDirectory)
if (self.parameters.bankDirectory != "none"): # none is used for tests only
self.initialize_banks_from_files(self.parameters.bankDirectory, self.get_state(0), 0)
logging.info(" banks read from directory: %s", self.parameters.bankDirectory)
else:
logging.error("ERROR: no bankDirectory given in %s\n", environment_filename)
self.initial_assets = 0.0 # the initial assets are needed to determine the fire-sale price in bank.liquidate_assets
for bank in self.banks:
self.initial_assets += bank.get_account("I")
# finally, create the network
# note: this has to be done after creating the banks, as they are
# passed to the network as node objects
self.network.identifier = self.identifier
self.network.initialize_networks(self)
# when there is a SIFI surcharge, implement it now on the banking capital
self.apply_sifi_surcharge()
# -------------------------------------------------------------------------
# -------------------------------------------------------------------------
# read_environment_file
# -------------------------------------------------------------------------
def read_environment_file(self, environmentFilename):
from xml.etree import ElementTree
xmlText = open(environmentFilename).read()
element = ElementTree.XML(xmlText)
self.identifier = element.attrib['title']
self.parameters.identifier = self.identifier
# loop over all entries in the xml file
for subelement in element:
# the first set of parameters will be valid for the whole simulation
if (subelement.attrib['type'] == 'numSweeps'):
self.parameters.numSweeps = int(subelement.attrib['value'])
if (subelement.attrib['type'] == 'numSimulations'):
self.parameters.numSimulations = int(subelement.attrib['value'])
if (subelement.attrib['type'] == 'numBanks'):
self.parameters.numBanks = int(subelement.attrib['value'])
if (subelement.attrib['type'] == 'bankDirectory'):
self.parameters.bankDirectory = str(subelement.attrib['value'])
if (subelement.attrib['type'] == 'graphType'):
self.parameters.graphType = str(subelement.attrib['value'])
if (subelement.attrib['type'] == 'graphParameter1'):
self.parameters.graphParameter1 = float(subelement.attrib['value'])
if (subelement.attrib['type'] == 'graphParameter2'):
self.parameters.graphParameter2 = float(subelement.attrib['value'])
if (subelement.attrib['type'] == 'contractsNetworkFile'):
self.parameters.contractsNetworkFile = str(subelement.attrib['value'])
# now also read in the parameters that can change during the simulation
if (subelement.attrib['type'] == 'changing'):
name = subelement.attrib['name']
value = float(subelement.attrib['value'])
validFrom = subelement.attrib['validity'].rsplit("-")[0]
validTo = subelement.attrib['validity'].rsplit("-")[1]
self.parameters.add_parameter(name, value, validFrom, validTo)
# -------------------------------------------------------------------------
# -------------------------------------------------------------------------
# write_environment_file(file_name)
# -------------------------------------------------------------------------
def write_environment_file(self, file_name):
out_file = open(file_name + "-check.xml", 'w')
text = "<environment title='" + self.identifier + "'>\n"
text += " <parameter type='numSweeps' value='" + str(self.parameters.numSweeps) + "'></parameter>\n"
text += " <parameter type='numSimulations' value='" + str(
self.parameters.numSimulations) + "'></parameter>\n"
text += " <parameter type='numBanks' value='" + str(self.parameters.numBanks) + "'></parameter>\n"
text += " <parameter type='bankDirectory' value='" + str(self.parameters.bankDirectory) + "'></parameter>\n"
text += " <parameter type='graphType' value='" + str(self.parameters.graphType) + "'></parameter>\n"
text += " <parameter type='contractsNetworkFile' value='" + str(
self.parameters.contractsNetworkFile) + "'></parameter>\n"
for entry in self.parameters.parameters:
text += " <parameter type='changing' name='" + str(entry['type']) + "' value='" + str(
entry['value']) + "' validity='" + str(entry['validity'][0]) + "-" + str(
entry['validity'][1]) + "'></parameter>\n"
text += "</environment>\n"
out_file.write(text)
out_file.close()
# -------------------------------------------------------------------------
# -------------------------------------------------------------------------
# initialize_banks_from_files
# banks have to be initialized for each simulation as a number of banks might become inactive
# in the previous simulation
# -------------------------------------------------------------------------
def initialize_banks_from_files(self, bankDirectory, state, time):
# this routine is called more than once, so we have to reset the list of banks each time
self.banks = []
listing = os.listdir(bankDirectory)
# print('listing', listing)
if len(listing) != self.parameters.numBanks:
logging.error(" ERROR: number of configuration files in %s (=%s) does not match numBanks (=%s)",
bankDirectory, str(len(listing)), str(self.parameters.numBanks))
for infile in listing:
# print("infile", infile)
bank = Bank()
bank.get_parameters_from_file(bankDirectory + infile, self.get_state(0), self.parameters.numBanks, time)
# print("bank", bank)
self.banks.append(bank)
bank.__del__() # TODO not sure if this is really safe, but it is better than doing nothing about all those created instances...
# -------------------------------------------------------------------------
# -------------------------------------------------------------------------
# get_state
# -------------------------------------------------------------------------
def get_state(self, time): # TODO bring parameters in same order as in environment file and in state.__str__()
# for each time t in the simulation return the actual set of parameters
for parameter in self.parameters.parameters:
validFrom = int(parameter['validity'][0])
validTo = int(parameter['validity'][1])
if (int(time) >= int(validFrom)) and (int(time) <= int(validTo)): # we have a valid parameterset
if parameter['type'] == 'rb':
self.state.rb = float(parameter['value'])
if parameter['type'] == 'rd':
self.state.rd = float(parameter['value'])
if parameter['type'] == 'r':
self.state.r = float(parameter['value'])
if parameter['type'] == 'collateralQuality':
self.state.collateralQuality = float(parameter['value'])
if parameter['type'] == 'successProbabilityFirms':
self.state.successProbabilityFirms = float(parameter['value'])
if parameter['type'] == 'positiveReturnFirms':
self.state.positiveReturnFirms = float(parameter['value'])
if parameter['type'] == 'scaleFactorHouseholds':
self.state.scaleFactorHouseholds = float(parameter['value'])
if parameter['type'] == 'dividendLevel':
self.state.dividendLevel = float(parameter['value'])
if parameter['type'] == 'pFinancial':
self.state.pFinancial = float(parameter['value'])
if parameter['type'] == 'rhoFinancial':
self.state.rhoFinancial = float(parameter['value'])
if parameter['type'] == 'pReal':
self.state.pReal = float(parameter['value'])
if parameter['type'] == 'rhoReal':
self.state.rhoReal = float(parameter['value'])
if parameter['type'] == 'xiBank':
self.state.xiBank = float(parameter['value'])
if parameter['type'] == 'thetaBank':
self.state.thetaBank = float(parameter['value'])
if parameter['type'] == 'rhoBank':
self.state.rhoBank = float(parameter['value'])
if parameter['type'] == 'shockType':
self.state.shockType = int(parameter['value'])
if parameter['type'] == 'gammaBank':
self.state.gammaBank = float(parameter['value'])
if parameter['type'] == 'assetNumber':
self.state.assetNumber = float(parameter['value'])
if parameter['type'] == 'liquidationDiscountFactor':
self.state.liquidationDiscountFactor = float(parameter['value'])
if parameter['type'] == 'riskAversionDiscountFactor':
self.state.riskAversionDiscountFactor = float(parameter['value'])
if parameter['type'] == 'riskAversionAmplificationFactor':
self.state.riskAversionAmplificationFactor = float(parameter['value'])
if parameter['type'] == 'interbankLoanMaturity':
self.state.interbankLoanMaturity = float(parameter['value'])
if parameter['type'] == 'firmLoanMaturity':
self.state.firmLoanMaturity = float(parameter['value'])
if parameter['type'] == 'sifiSurchargeFactor':
self.state.sifiSurchargeFactor = float(parameter['value'])
if parameter['type'] == 'requiredCapitalRatio':
self.state.requiredCapitalRatio = float(parameter['value'])
if parameter['type'] == 'liquidityCoverageRatio':
self.state.liquidityCoverageRatio = float(parameter['value'])
if parameter['type'] == 'netStableFundingRatio':
self.state.netStableFundingRatio = float(parameter['value'])
if parameter['type'] == 'leverageRatio':
self.state.leverageRatio = float(parameter['value'])
#
# at this point we have all the variables from the parameters[] list
# now we need to update them to incorporate past defaults to calculate
# new return and volatility for real and financial assets
self.state.update_state(time)
return self.state
# -------------------------------------------------------------------------
# -------------------------------------------------------------------------
# apply_sifi_surcharge
# -------------------------------------------------------------------------
def apply_sifi_surcharge(self):
degree_sum = 0
for bank in self.network.contracts:
degree_sum += float(nx.degree(self.network.contracts)[bank])
average_degree = float(degree_sum / len(self.network.contracts.nodes()))
for bank in self.network.contracts:
# the sifi surcharge is the product of the sifiSurchargeFactor and the connectedness as measured
# by degree/average_degree
# the maximum ensures that no bank has to hold less than 1.0 times their banking capital
sifiSurcharge = max(self.get_state(0).sifiSurchargeFactor * (
float(nx.degree(self.network.contracts)[bank]) / average_degree), 1.0)
bank.apply_sifi_surcharge(sifiSurcharge)
"""Tests the functionality of parameters_class"""
from src.preprocessing import import_wsj
from src.parameters import Parameters
sentences = import_wsj('train')
params = Parameters(sentences)
## examples of parameteres
print("q(<STOP>|NN,.): ", params.q('<STOP>', 'NN', '.'))
print("e(the|DT): ", params.e("the", "DT"))
print("If the time between now ...")
params.q('NN', 'DT', 'NN')
params.q('NN', 'DT', 'NN')
params.q('NN', 'DT', 'NN')
params.q('NN', 'DT', 'NN')
params.q('NN', 'DT', 'NN')
print("... and now is not long, than the class is preserving counts.")
class Decoder:
def __init__(self, corpus_name, rarity=5):
"""Initialize parameters using a corpus
Parameters q (transition) and e (emission) are calculated by eponymous
functions from the class Parameters using counts over the corpus.
See parameters_class.py for details.
The corpus must be from the Penn WSJ treebank
corpus_name can be one of three names:
"train" uses /Users/ischeinfeld/Documents/Code/WSJ/train.txt
"develop" uses /Users/ischeinfeld/Documents/Code/WSJ/develop.txt"
"test" uses /Users/ischeinfeld/Documents/Code/WSJ/test.txt"
or corpus_name can be a complete path to the corpus text:
ex. /dir/dir/dir/file(.txt)
"""
### Create instance of Parameters with the given corpus
# Note that this completes all the counts for q and e
self.corpus = import_wsj(corpus_name)
self.params = Parameters(self.corpus)
def decode(self, sentence):
"""Decode a sentence
Input: a sentence (str)
Output: a tuple with lists of tokens and tags
"""
if isinstance(sentence, str):
token_seq = self.prep_sentence(sentence) # Tokenize sentence
#print("decoder_class_log, token_seq from string", token_seq)
else:
token_seq = sentence[0] # Already tokenized
#print("decoder_class_log, token_seq from list", token_seq)
for i in range(len(token_seq)): # Replace rare words
token_seq[i] = self.params.rep_rare_input(token_seq[i])
print("Token sequence after replacing rarities:", token_seq)
### Calculate pi values (log probabilities) and store back pointers
pi = []
bp = []
tags = self.params.tags
pi.append({})
pi[0]['<START>'] = {}
pi[0]['<START>']['<START>'] = 0 # pi[k][u][v] = 0 because log1 = 0
bp.append({})
bp[0]['<START>'] = {}
bp[0]['<START>']['<START>'] = None # pi[k][u][v]
for k in range(1, len(token_seq) + 1):
pi.append({}) # pi[k] = {}
bp.append({}) # bp[k] = {}
for u in tags:
pi[k][u] = {}
bp[k][u] = {}
for v in tags:
max = float('-inf')
pi[k][u][v] = max # Pi value
bp[k][u][v] = None # back pointer value
for w in pi[k-1].keys():
try:
print("marker")
log_prob = (pi[k-1][w][u] + log(self.params.q(v, w, u))
+ log(self.params.e(token_seq[k - 1],v)))
# token_seq[k-1] is the token at v
except KeyError:
log_prob = float('-inf')
except ValueError:
log_prob = float('-inf')
if log_prob >= max: # Explicit
max = log_prob
pi[k][u][v] = log_prob # New max log probability
bp[k][u][v] = w # Backpointer to w
### Find last two tags, using <STOP> transition probability
max = float('-inf')
for u in tags:
for v in tags:
try:
log_prob = (pi[len(token_seq)][u][v]
+ log(self.params.q('<STOP>', u, v)))
except KeyError:
log_prob = float('-inf')
except ValueError:
log_prob = float('-inf')
if log_prob >= max: # Explicit
max = log_prob
yn, yn_1 = v, u # | yn is y sub n | yn_1 is y sub (n-1)
### Get tag sequence using backtracking
tag_seq = [] # Replace with ['<START>', '<START>'] if desired
for word in token_seq:
tag_seq.append(None)
tag_seq[-1] = yn
tag_seq[-2] = yn_1
for i in range(len(tag_seq) - 3, -1, -1):
tag_seq[i] = bp[i+3][tag_seq[i+1]][tag_seq[i+2]]
print("Log probability is:", max)
print("Probability is:", exp(max))
return (token_seq, tag_seq)
def prep_sentence(self, sentence):
"""Tokenizes a sentence string"""
sentence_list = TreebankWordTokenizer().tokenize(sentence)
return sentence_list
# print_ss(ss[:ss_ini.size//2])
# print('objD', objD)
if constraints.sym:
ss[ss.size // 2 + ss.size % 2:] = np.flip(ss[:ss.size // 2])
if count_obj:
return ss, n_obj_func_D_calls
return ss
if __name__ == "__main__":
print('\n*** Test for the function repair_flexural_4 ***')
constraints = Constraints(sym=True, dam_tol=True)
parameters = Parameters(repair_flexural_switch=True,
n_D2=2,
constraints=constraints)
ss = np.array([
0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45,
45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0,
45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0,
0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45,
45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0,
0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45,
45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0,
45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0,
0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0
], int)
if constraints.sym:
ss = np.hstack((ss, 0, np.flip(ss)))
def __init__(self, experiment: str, scenario: str, run: str):
""" Ldm: Location & Disease model - a class built to run agent-based simulations.
Current disease models implemented:
- cdi: Use: "disease_model": "cdi" in the parameters.json
- cre: Use: "disease_model": "cre"
"""
# ----- Setup the model directory structure
self.experiment_dir = Path(experiment)
self.scenario_dir = Path(self.experiment_dir, scenario)
self.run_dir = Path(self.scenario_dir, run)
self.output_dir = Path(self.run_dir, "model_output")
self.run_dir.mkdir(exist_ok=True)
self.output_dir.mkdir(exist_ok=True)
# ----- Setup the model parameters
self.params = Parameters(Path(self.run_dir, "parameters.json"))
self.seed = self.params.base["seed"]
self.rng = np.random.RandomState(self.seed)
self.time = 0
self.daily_counts = pd.DataFrame()
# ----- Population
self.population = self.read_population()
self.unique_ids = np.array(self.population.index.values, dtype=np.int32)
self.county_codes = self.population.County_Code.values
self.age_groups = self.population.Age.values
self.logrecnos = self.population.logrecno.values
self.population = self.population.drop(
["County_Code", "Age", "logrecno"], axis=1
)
self.concurrent_conditions = assign_conditions(
self.age_groups, self.rng.rand(len(self.population))
)
# ----- For Event Tracking: Create the SQL Connection
self.event_columns = [
"Unique_ID",
"Time",
"State",
"Location",
"LOS",
"Old",
"New",
"County",
]
self.conn, self.cur = None, None
self.create_sql_connection()
self.location = location_models[self.params.base["location_model"]](
model=self, params=self.params.location
)
self.disease = disease_models[self.params.base["disease_model"]](
model=self, params=self.params.disease
)
life_dict = dict()
for k1, v1 in self.params.life["death_probabilities"].items():
for k2, v2 in self.params.life["death_multipliers"].items():
life_dict[
AgeGroup[k1].value, self.location.locations.category_enum[k2].value
] = (v1 * v2)
self.life = Life(
model=self,
params=self.params.life,
enum=LifeState,
transition_dict=life_dict,
key_types=[AgeGroup, self.location.locations.category_enum],
)
# --- Death probability is based on Age + Location
locations = [
self.location.locations.convert_int(l, "int_category")
for l in self.location.location.values
]
self.life.probabilities = self.life.find_probabilities(
list(zip(self.age_groups, locations))
)
self.disease.collect_agents(initiate=True)
