def insert_data():
#Contacts
contacts = []
mary_sue_client = Contact('Mary Sue', "Client")
contacts.append(mary_sue_client)
john_doe_agent = Contact('John Doe', 'Agent')
contacts.append(john_doe_agent)
john_doe_insured = Contact('John Doe', 'Named Insured')
contacts.append(john_doe_insured)
bob_smith = Contact('Bob Smith', 'Agent')
contacts.append(bob_smith)
anna_white = Contact('Anna White', 'Named Insured')
contacts.append(anna_white)
joe_lee = Contact('Joe Lee', 'Agent')
contacts.append(joe_lee)
ryan_bucket = Contact('Ryan Bucket', 'Named Insured')
contacts.append(ryan_bucket)
for contact in contacts:
db.session.add(contact)
db.session.commit()
policies = []
p1 = Policy('Policy One', date(2015, 1, 1), 365)
p1.billing_schedule = 'Annual'
p1.agent = bob_smith.id
policies.append(p1)
p2 = Policy('Policy Two', date(2015, 2, 1), 1600)
p2.billing_schedule = 'Quarterly'
p2.named_insured = anna_white.id
p2.agent = joe_lee.id
policies.append(p2)
p3 = Policy('Policy Three', date(2015, 1, 1), 1200)
p3.billing_schedule = 'Monthly'
p3.named_insured = ryan_bucket.id
p3.agent = john_doe_agent.id
policies.append(p3)
p4 = Policy("Policy Four", date(2015, 2, 1), 500)
p4.billing_schedule = 'Two-Pay'
p4.named_insured = ryan_bucket.id
p4.agent = john_doe_agent.id
policies.append(p4)
for policy in policies:
db.session.add(policy)
db.session.commit()
for policy in policies:
PolicyAccounting(policy.id)
payment_for_p2 = Payment(p2.id, anna_white.id, 400, date(2015, 2, 1))
db.session.add(payment_for_p2)
db.session.commit()
def insert_data():
# Contacts
contacts = []
john_doe_agent = Contact("John Doe", "Agent")
contacts.append(john_doe_agent)
john_doe_insured = Contact("John Doe", "Named Insured")
contacts.append(john_doe_insured)
bob_smith = Contact("Bob Smith", "Agent")
contacts.append(bob_smith)
anna_white = Contact("Anna White", "Named Insured")
contacts.append(anna_white)
joe_lee = Contact("Joe Lee", "Agent")
contacts.append(joe_lee)
ryan_bucket = Contact("Ryan Bucket", "Named Insured")
contacts.append(ryan_bucket)
for contact in contacts:
db.session.add(contact)
db.session.commit()
policies = []
p1 = Policy("Policy One", date(2015, 1, 1), 365)
p1.billing_schedule = "Annual"
p1.named_insured = john_doe_insured.id
p1.agent = bob_smith.id
policies.append(p1)
p2 = Policy("Policy Two", date(2015, 2, 1), 1600)
p2.billing_schedule = "Quarterly"
p2.named_insured = anna_white.id
p2.agent = joe_lee.id
policies.append(p2)
p3 = Policy("Policy Three", date(2015, 1, 1), 1200)
p3.billing_schedule = "Monthly"
p3.named_insured = ryan_bucket.id
p3.agent = john_doe_agent.id
policies.append(p3)
p4 = Policy("Policy Four", date(2015, 2, 1), 500)
p4.billing_schedule = "Two-Pay"
p4.named_insured = ryan_bucket.id
p4.agent = john_doe_agent.id
policies.append(p4)
for policy in policies:
db.session.add(policy)
db.session.commit()
for policy in policies:
PolicyAccounting(policy.id)
payment_for_p2 = Payment(p2.id, anna_white.id, 400, date(2015, 2, 1))
db.session.add(payment_for_p2)
db.session.commit()
def test(rank, params, shared_p):
torch.manual_seed(params.seed + rank)
env = gym.make(params.env_name)
num_inputs = env.observation_space.shape[0]
num_outputs = env.action_space.shape[0]
policy = Policy(num_inputs, num_outputs)
state = env.reset()
state = Variable(torch.Tensor(state).unsqueeze(0))
reward_sum = 0
done = True
start_time = time.time()
episode_length = 0
while True:
episode_length += 1
policy.load_state_dict(shared_p.state_dict())
mu, _ = policy(state)
action = mu.data
env_action = action.squeeze().numpy()
state, reward, done, _ = env.step(env_action)
reward_sum += reward
if done:
print("Time {}, episode reward {}, episode length {}".format(
time.strftime("%Hh %Mm %Ss",
time.gmtime(time.time() - start_time)),
reward_sum, episode_length))
reward_sum = 0
episode_length = 0
state = env.reset()
time.sleep(60)
state = Variable(torch.Tensor(state).unsqueeze(0))
def init_training(opt):
# Initialize losses
losses = {
'adversarial': torch.nn.BCELoss(),
'pixelwise': torch.nn.L1Loss(),
'action': torch.nn.NLLLoss()
}
img_shape = (1, opt.img_size, opt.img_size)
# Initialize models
encoder = Encoder(img_shape, opt.latent_dim)
decoder = Decoder(img_shape, opt.latent_dim)
discriminator = Discriminator(opt.latent_dim)
model = {'enc': encoder, 'dec': decoder, 'discr': discriminator}
if opt.domain == 'source':
pol = Policy(opt.latent_dim, ac_size=3)
model['pol'] = pol
if opt.use_dynamics:
decoder_next = Decoder(img_shape, opt.latent_dim)
model['dec_next'] = decoder_next
if opt.domain == 'source':
dyn = Dynamics(opt.latent_dim, ac_size=3, ac_embed_size=10)
model['dyn'] = dyn
# move to GPU
if opt.cuda:
for loss in losses.values():
loss.cuda()
for network in model.values():
network.cuda()
# Optimizers
G_params = []
for name, network in model.items():
G_params += [network.parameters()] if name != 'discr' else []
G_params = itertools.chain(*G_params)
optimizer_G = torch.optim.Adam(G_params, lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(model['discr'].parameters(),
lr=opt.lr,
betas=(opt.b1, opt.b2))
# metrics
metrics_dict = {
'adv_losses': [],
'pix_losses': [],
'ac_losses': [],
'g_losses': [],
'd_losses': [],
'rf_z_sep_accs': [],
'pol_accs': []
}
if opt.use_dynamics:
metrics_dict['pix_next_losses'] = []
return model, losses, optimizer_G, optimizer_D, metrics_dict
def post_evaluate(models_path, sigma, n_post_episodes=5, add_noise=False):
# print('----------------Post evaluation----------------')
policy_path = models_path + "_policy"
value_path = models_path + "_value"
if args.use_parameter_noise:
policy_post = PolicyLayerNorm(num_inputs, num_actions)
value_post = Value(num_inputs)
else:
policy_post = Policy(num_inputs, num_actions)
value_post = Value(num_inputs)
# print('------------------')
value_post.load_state_dict(torch.load(value_path))
policy_post.load_state_dict(torch.load(policy_path))
reward_post = 0
for i in range(n_post_episodes):
state = env.reset()
##seeding
# env.seed(i)
# torch.manual_seed(i)
# state = running_state(state)
for t in range(1000):
if args.use_parameter_noise and add_noise:
action = select_action(policy_post,
state,
sigma,
add_noise=True)
else:
action = select_action(policy_post, state)
action = action.data[0].numpy()
next_state, reward, done, _ = env.step(action)
reward_post += reward
# next_state = running_state(next_state)
if done:
break
# state = running_state(next_state)
state = next_state
print('___Post evaluation reward___')
print(reward_post / n_post_episodes)
return reward_post / n_post_episodes
def initialize(self):
print('Build Environment for {}'.format(self.actor_name))
if self.env is None:
self.env = Env(self.args,
self.device,
options=self.args.options,
dummy=self.args.dummy,
rank=self.rank)
self.policy = Policy(self.env.action_dim).to(self.device)
self.memory = Memory()
def make_policy(self, policy_number, effective_date, annual_premium):
"""
Create a new policy method.
"""
policy = Policy(policy_number, effective_date, annual_premium)
db.session.add(policy)
db.session.commit()
return policy
def setUpClass(cls):
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
db.session.add(cls.policy)
db.session.commit()
cls.invoice_1 = Invoice(cls.policy.id, date(2015, 1, 1), date(2015, 1, 15), date(2015, 2, 1), 50)
cls.invoice_2 = Invoice(cls.policy.id, date(2015, 3, 1), date(2015, 3, 1), date(2015, 2, 1), 20)
db.session.add(cls.invoice_1)
db.session.add(cls.invoice_2)
db.session.commit()
def setUp(self):
self.policy = Policy("Test Policy", date(2015, 1, 1), 1200)
self.policy.named_insured = self.test_insured.id
self.policy.agent = self.test_agent.id
self.policy.billing_schedule = "Quarterly"
db.session.add(self.policy)
db.session.commit()
self.pa = PolicyAccounting(self.policy.id)
self.payments = []
def save(self, data: Dict):
try:
action = data['action']
data['action'] = int(action) if '1' <= action <= '6' else action
policy = Policy(data)
policy.save()
except ValueError as err:
raise ValidationError(
message=str(err)
)
def setUpClass(cls):
cls.test_agent = Contact("Test Agent", "Agent")
cls.test_insured = Contact("Test Insured", "Named Insured")
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy("Test Policy", date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.add(cls.policy)
db.session.commit()
def setUpClass(cls):
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.add(cls.policy)
db.session.commit()
def __init__(self, config):
self.config = config
# for universe-starter-agent
self.var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
tf.get_variable_scope().name)
# build some graph nodes
self.inputs_s = tf.placeholder(
tf.float32, [None] + [config.n_actions, config.rollout_length] +
config.state_dims)
self.inputs_r = tf.placeholder(
tf.float32, [None] + [config.n_actions, config.rollout_length])
self.X = tf.placeholder(tf.float32, [None] + config.state_dims)
# instantiate the model free policy
self.mf_policy = justCNN
with tf.variable_scope('mf_policy', reuse=config.reuse):
mf_feats = self.mf_policy(self.X)
mf_feats = layers.flatten(mf_feats)
# instantiate the rollout policy
self.rollout_policy = Policy(natureCNN, config)
with tf.variable_scope('rollout_policy', reuse=config.reuse):
self.rp_logits, rp_pi, rp_actions, rp_vf = self.rollout_policy.forward(
self.X)
# instantiate the imagination core
# we can only instantiate this once we have defined our rollout policy
self.imagination_core = ImaginationCore(config, self.rollout_policy)
# instantiate the encoder
self.encoder = Encoder(justCNN, config)
with tf.variable_scope('encoder', reuse=config.reuse):
encodings = self.encoder.forward(self.inputs_s, self.inputs_r)
aggregate = tf.reshape(
encodings, shape=[-1, config.n_actions * config.hidden_dim])
# we can experiment with this next line of code
# you can either concat, add, or multiply
i2a_inputs = tf.concat([aggregate, mf_feats], -1)
# instantiate the I2A policy
self.i2a_policy = Policy(linear, config)
with tf.variable_scope('i2a_policy', reuse=config.reuse):
self.logits, self.pi, self.actions, self.vf = self.i2a_policy.forward(
i2a_inputs)
def __init__(self):
super(VAE, self).__init__()
self.policy = Policy(state_size=8,
action_size=0,
latent_size=2,
output_size=4,
hidden_size=64,
output_activation='sigmoid')
self.posterior = Posterior(state_size=8,
action_size=0,
latent_size=2,
hidden_size=64)
def setUpClass(cls):
# print "Setting up TestReturnAccountBalance class..."
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.add(cls.policy)
db.session.commit()
def load_models(args, state_size, n_drones, action_size):
nets = []
for i in range(n_drones):
model = Policy(state_size,
n_drones,
action_size,
policy_type=args.policy)
model.load_state_dict(
torch.load(
f"A2C_models/{args.policy}_policy/A2C_drone_{icm_model_name}{i}.bin"
))
nets.append(model)
return nets
def test_evaluate_cancel(self):
policy = Policy('Test Policy', date(2015, 1, 1), 1200)
policy.named_insured = self.test_insured.id
policy.agent = self.test_agent.id
self.policies.append(policy)
db.session.add(policy)
db.session.commit()
# Get the policy from the database
policy.billing_schedule = "Monthly"
pa = PolicyAccounting(policy.id)
# Make a payment
self.payments.append(pa.make_payment(date_cursor=date(2015, 01, 01), amount=100))
def test_payment_contact_id_data(self):
# Create and store a policy without a named insured
policy = Policy('Test Policy', date(2015, 1, 1), 1200)
policy.named_insured = None
policy.agent = self.test_agent.id
self.policies.append(policy)
db.session.add(policy)
db.session.commit()
# Get the policy from the database
policy.billing_schedule = "Annual"
pa = PolicyAccounting(policy.id)
# Try to create a payment without a contact id specified, no payment should be registered
self.assertFalse(pa.make_payment(date_cursor=date(2015, 01, 01), amount=1200))
def setUpClass(cls):
print "Setting up TestBillingSchedules class..."
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2015, 1, 1), 1200)
db.session.add(cls.policy)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.commit()
print "Class set up!\n"
def setUpClass(cls):
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Named Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2018, 10, 1), 1870)
db.session.add(cls.policy)
db.session.commit()
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
cls.policy.billing_schedule = 'Monthly'
db.session.commit()
def setUp(self):
self.policy = Policy("Test Policy", date(2015, 1, 1), 1200)
self.policy.named_insured = self.test_insured.id
self.policy.agent = self.test_agent.id
self.policy.billing_schedule = "Quarterly"
db.session.add(self.policy)
db.session.commit()
self.pa = PolicyAccounting(self.policy.id)
invoice = self.policy.invoices[0]
self.payment = self.pa.make_payment(
contact_id=self.policy.named_insured,
date_cursor=invoice.bill_date,
amount=invoice.amount_due,
)
def setUpClass(cls):
cls.test_agent = Contact("Test Agent", "Agent")
cls.test_insured = Contact("Test Insured", "Named Insured")
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy("Test Policy", date(2015, 1, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
cls.policy.billing_schedule = "Quarterly"
db.session.add(cls.policy)
db.session.commit()
cls.pa = PolicyAccounting(cls.policy.id)
def setUpClass(cls):
# print "Setting up TestChangeBillingSchedule class..."
cls.test_agent = Contact('Test Joe Lee', 'Agent')
cls.test_insured = Contact('Test Anna White', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy Two', date(2015, 2, 1), 1600)
db.session.add(cls.policy)
db.session.commit()
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
cls.policy.billing_schedule = 'Quarterly'
db.session.commit()
def create(**kw):
kw['state'] = None
now = utc_8_now()
kw['create_time'] = now
kw['update_time'] = now
# 参数合法性检查. 如果不合法,直接报错.
is_valid_kw(Policy, **kw)
# 检查id,policy_name, 如果存在record, 不允许添加
sanity_check = Policy.find_by('id, policy_name',
'where id=? OR policy_name=?',
*[kw['id'], kw['policy_name']])
if sanity_check:
raise ValueError(
"Already exist record with id=[%s], policy_name=[%s]." %
(sanity_check[0]['id'], sanity_check[0]['policy_name']))
policy = Policy(**kw)
policy.insert()
def new_policy(policy_number,
effective_date,
annual_premium,
billing_schedule,
agent=None,
named_insured=None):
try:
# makes a new policy object
new_policy = Policy(policy_number, effective_date, annual_premium)
new_policy.billing_schedule = billing_schedule
# check if a named_insured was passed, if it was passed get the reference object from the db
if named_insured:
named_insured_ = Contact.query.filter_by(
name=named_insured, role="Named Insured").first()
# if there is not a contact with this name a new one is created
if not named_insured_:
contact = Contact(named_insured, 'Named Insured')
named_insured_ = contact
db.session.add(contact)
db.session.commit()
named_insured = named_insured_.id
# check if a agent was passed, if it was passed get the reference object from the db
if agent:
agent_ = Contact.query.filter_by(name=agent, role="Agent").first()
# if there is not a contact with this name a new one is created
if not agent_:
contact = Contact(agent, 'Agent')
agent_ = contact
db.session.add(contact)
db.session.commit()
agent = agent_.id
new_policy.named_insured = named_insured
new_policy.agent = agent
db.session.add(new_policy)
db.session.commit()
except Exception as error:
logging.error(error)
def create_network(self, data):
goals = data['goals']
policies = data['policies']
id_mapping = {}
links = []
network = Network()
for policy in policies:
p = Policy(id=policy['id'])
update_node_from_dict(p, policy)
id_mapping[policy['id']] = p
network.policies[p.id] = p
for conn in policy['connections']:
i = conn['id']
a = conn['from_id']
b = conn['to_id']
w = conn['weight']
links.append((i, a, b, w))
for goal in goals:
g = Goal(id=goal['id'])
update_node_from_dict(g, goal)
id_mapping[goal['id']] = g
network.goals[g.id] = g
for conn in goal['connections']:
i = conn['id']
a = conn['from_id']
b = conn['to_id']
w = conn['weight']
links.append((i, a, b, w))
for i, a, b, w in links:
a = id_mapping[a]
b = id_mapping[b]
l = Edge(id=i)
l.init(a, b, w)
network.edges[l.id] = l
network.rank()
self.network = network
def setUpClass(cls):
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.commit()
cls.policy = Policy('Test Policy', date(2015, 2, 1), 1200)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
cls.policy.billing_schedule = "Quarterly"
db.session.add(cls.policy)
db.session.commit()
cls.payments = Payment(cls.policy.id, cls.test_insured.id, 300,
date(2015, 2, 1))
db.session.add(cls.payments)
db.session.commit()
def setUpClass(cls):
try:
cls.test_agent = Contact('Test Agent', 'Agent')
cls.test_insured = Contact('Test Insured', 'Named Insured')
db.session.add(cls.test_agent)
db.session.add(cls.test_insured)
db.session.flush()
cls.policy = Policy('Policy test', date(2015, 1, 5), 400)
cls.policy.named_insured = cls.test_insured.id
cls.policy.agent = cls.test_agent.id
db.session.add(cls.policy)
db.session.flush()
db.session.commit()
except Exception as error:
print(error)
db.session.rollback()
def create_policy_four():
# get contact whose name and Role are John Doe and role respectively
john_doe_agent = Contact.query.filter_by(name="John Doe",
role="Agent").one()
# get contact whose name and Role are Ryan Bucket and Name Insured respectively
ryan_bucket = Contact.query.filter_by(name="Ryan Bucket",
role="Named Insured").one()
# create a policy instance for Policy Four with annual amount of $500
p4 = Policy('Policy Four', date(2015, 2, 1), 500)
p4.billing_schedule = 'Two-Pay' # billing schedule
p4.agent = john_doe_agent.id # agent
p4.named_insured = ryan_bucket.id # named insured
# save Policy Four to database
db.session.add(p4)
db.session.commit()
# Use PolicyAccounting to create invoice(s) for Policy Four
PolicyAccounting(p4.id)
print "Policy Four Created and invoices are generated for it"
def create_policy():
data = request.json
try:
curr_date = datetime.strptime(data['date'], "%Y-%m-%d")
policy_name = data['policy_name']
existing_insured = data['existingInsured']
existing_agent = data['existingAgent']
insured = data['insured']
agent = data['agent']
billing_schedule = data['schedule']
premium = int(data['premium'])
except:
abort(400)
if not existing_insured:
new_insured = Contact(insured, 'Named Insured')
db.session.add(new_insured)
db.session.commit()
insured = new_insured.id
else:
insured = insured['id']
if not existing_agent:
new_agent = Contact(agent, 'Agent')
db.session.add(new_agent)
db.session.commit()
agent = new_agent.id
else:
agent = agent['id']
new_policy = Policy(policy_name, curr_date, premium)
new_policy.billing_schedule = billing_schedule
new_policy.named_insured = insured
new_policy.agent = agent
db.session.add(new_policy)
db.session.commit()
return "All good"
