def rewards():
if 'userid' in session:
user = User.query.get_or_404(session['userid'])
if request.method == 'POST':
form = RewardForm(request.form)
if form.validate():
print form.cost.data
newreward = Reward(form.title.data, user, None, form.cost.data)
db.session.add(newreward)
db.session.commit()
return redirect(url_for('rewards'))
else:
rewards = user.rewards.filter(
Reward.redeemed == False).order_by(desc(
Reward.dateadded)).all()
return render_template('rewards.html',
username=user.username,
points=user.points,
rewards=rewards,
form=form,
idform=RewardIdForm(),
updateform=RewardUpdateForm(),
containerclass="rewardcontainer")
else:
rewards = user.rewards.filter(Reward.redeemed == False).order_by(
desc(Reward.dateadded)).all()
return render_template('rewards.html',
username=user.username,
points=user.points,
rewards=rewards,
form=RewardForm(),
idform=RewardIdForm(),
updateform=RewardUpdateForm(),
containerclass="rewardcontainer")
# if no session, display default home page. TODO: convert to splash page
else:
return redirect(url_for('front'))
def user_rewards(user_id):
# Get the user account relevant to the user_id parameter
user = User.query.get(user_id)
# Verify the logged in user is actually the user or an attached user.
verify_user(user)
if request.method == 'GET':
# Return the user's rewards in JSON format.
return jsonify(rewards=[r.serialize() for r in user.rewards])
elif request.method == 'POST':
required_json = ['name', 'cost']
json = request.json
if not valid_json(json, required_json):
abort(400)
reward = Reward(name=json.get('name'), cost=json.get('cost'), user_id=user_id)
db.session.add(reward)
db.session.commit()
notify_if_partner("A new reward is available in the store!")
return jsonify(reward.serialize()), 201
def __init__(self,
args,
logger,
state_size=2,
action_size=4,
context_size=1,
num_goals=4,
history_size=1,
dtype=torch.FloatTensor):
super(InfoGAIL, self).__init__(args,
logger,
state_size=state_size,
action_size=action_size,
context_size=context_size,
num_goals=num_goals,
history_size=history_size,
dtype=dtype)
# Create networks
self.policy_net = Policy(state_size=state_size * history_size,
action_size=0,
latent_size=context_size,
output_size=action_size,
hidden_size=64,
output_activation='sigmoid')
self.old_policy_net = Policy(state_size=state_size * history_size,
action_size=0,
latent_size=context_size,
output_size=action_size,
hidden_size=64,
output_activation='sigmoid')
# Use value network for calculating GAE. We should use this for
# training the policy network.
if args.use_value_net:
# context_size contains num_goals
self.value_net = Value(state_size * history_size + context_size,
hidden_size=64)
# Reward net is the discriminator network. Discriminator does not
# receive the latent vector in InfoGAIL.
self.reward_net = Reward(
state_size * history_size,
action_size, # action size
0, # latent size
hidden_size=64)
self.posterior_net = DiscretePosterior(
state_size=state_size * history_size, # state
action_size=0, # action
latent_size=0, # context
hidden_size=64,
output_size=num_goals)
self.opt_policy = optim.Adam(self.policy_net.parameters(), lr=0.0003)
self.opt_reward = optim.Adam(self.reward_net.parameters(), lr=0.0003)
self.opt_value = optim.Adam(self.value_net.parameters(), lr=0.0003)
self.opt_posterior = optim.Adam(self.posterior_net.parameters(),
lr=0.0003)
# Create loss functions
self.criterion = nn.BCELoss()
self.criterion_posterior = nn.CrossEntropyLoss()
self.create_environment()
def create_new_reward(current_user):
create_table = Reward(author = current_user, coins = 0)
db.session.add(create_table)
db.session.commit()
# Initialise training environment and experience replay memory
env = GymEnv(cfg)
replay = Replay(cfg, env.action_size)
# Initialise dataset replay with S random seed episodes
for s in range(cfg['seed_episodes']):
observation = env.reset()
done = False
while not done:
next_observation, action, reward, done = env.step()
replay.append(observation, action, reward, done)
observation = next_observation
# Init PlaNet
transition_model = Transition(cfg)
observation_model = Observation(cfg)
reward_model = Reward(cfg)
encoder = Encoder(cfg)
optim = tf.train.AdamOptimizer(cfg['learning_rate'], epsilon=cfg['optim_eps'])
planner = MPCPlanner(cfg, env.action_size, transition_model, reward_model)
global_prior = tf.distributions.Normal(
tf.zeros([cfg['batch_size'], cfg['state_size']]),
tf.ones([cfg['batch_size'], cfg['state_size']])) # Global prior N(0, I)
free_nats = tf.fill(dims=[
1,
], value=cfg['free_nats']) # Allowed deviation in KL divergence
# Training
for episode in trange(cfg['train']['episodes']):
# Model fitting
losses = []
id=uuid.uuid4(),
text=dummy_text,
user_id=ted.id,
)
c.updates.append(ci)
for i in range(6):
inventory_count = randint(1, 500)
r = Reward(
id=uuid.uuid4(),
title='Something Awesome%s' % i,
description=
"This is the description and lets see it a little longer then normal. This is the description and lets see it a little longer then normal. This is the description and lets see it a little longer then normal. ",
thumbnail_url=
"http://res.cloudinary.com/hzdmrhkl4/image/upload/v1398927057/hs9gf9a9lbvjenzpsomo.jpg",
is_active=True,
is_available=True,
cost=randint(50, 500),
delivery_date="2014-05-22 00:00:00",
inventory=inventory_count,
is_limited_quantity=True,
is_shipping_required=True,
claimed=randint(1, inventory_count))
c.rewards.append(r)
db.session.add(c)
db.session.commit()
for i in range(30):
b = User(first_name=str('Joe%s' % i),
last_name=str('Backer%s' % i),
env = gym.make(args.env_name)
num_inputs = env.observation_space.shape[0]
num_actions = env.action_space.shape[0]
env.seed(args.seed)
torch.manual_seed(args.seed)
if args.use_joint_pol_val:
ac_net = ActorCritic(num_inputs, num_actions)
opt_ac = optim.Adam(ac_net.parameters(), lr=0.0003)
else:
policy_net = Policy(num_inputs, num_actions)
old_policy_net = Policy(num_inputs, num_actions)
value_net = Value(num_inputs)
reward_net = Reward(num_inputs, num_actions)
opt_policy = optim.Adam(policy_net.parameters(), lr=0.0003)
opt_value = optim.Adam(value_net.parameters(), lr=0.0003)
opt_reward = optim.Adam(reward_net.parameters(), lr=0.0003)
def select_action(state):
state = torch.from_numpy(state).unsqueeze(0)
action_mean, _, action_std = policy_net(Variable(state))
action = torch.normal(action_mean, action_std)
return action
def select_action_actor_critic(state):
state = torch.from_numpy(state).unsqueeze(0)
action_mean, _, action_std, v = ac_net(Variable(state))
torch.manual_seed(args.seed)
policy_net = Policy(num_inputs,
0,
num_c,
num_actions,
hidden_size=64,
output_activation='sigmoid').type(dtype)
old_policy_net = Policy(num_inputs,
0,
num_c,
num_actions,
hidden_size=64,
output_activation='sigmoid').type(dtype)
#value_net = Value(num_inputs+num_c, hidden_size=64).type(dtype)
reward_net = Reward(num_inputs, num_actions, num_c, hidden_size=64).type(dtype)
posterior_net = Posterior(num_inputs, num_actions, num_c,
hidden_size=64).type(dtype)
opt_policy = optim.Adam(policy_net.parameters(), lr=0.0003)
#opt_value = optim.Adam(value_net.parameters(), lr=0.0003)
opt_reward = optim.Adam(reward_net.parameters(), lr=0.0003)
opt_posterior = optim.Adam(posterior_net.parameters(), lr=0.0003)
def epsilon_greedy_linear_decay(action_vector,
n_episodes,
n,
low=0.1,
high=0.9):
if n <= n_episodes:
def save_draft_to_campaign(self, campaign, draft_data):
form_campaign_info = CampaignInfoForm.from_json(
draft_data["form_campaign_info"])
form_basics = CampaignBasicForm.from_json(draft_data["form_basics"])
form_paid = CampaignPaidForm.from_json(draft_data["form_paid"])
form_bonus_reward = CampaignBonusRewardForm.from_json(
draft_data["form_bonus_reward"])
form_confirmation_message = CampaignConfirmationMessageForm.from_json(
draft_data["form_confirmation_message"])
campaign.campaign_type_id = form_basics.campaign_type_id.data
campaign.category_id = form_basics.category_id.data
campaign.campaign_receiver_id = form_basics.campaign_receiver_id.data
campaign.funding_goal = float(str(form_basics.dollar_amount.data))
campaign.expiration_date = form_basics.deadline.data
campaign.fulfillment_service = form_basics.fulfillment_service.data
campaign.evergreen_campaign_page = form_basics.evergreen_campaign_page.data
campaign.fulfillment_service = form_basics.fulfillment_service.data
campaign.campaign_management = form_basics.campaign_management.data
campaign.description = form_campaign_info.full_description.data
campaign.short_description = form_campaign_info.description.data
campaign.title = form_campaign_info.campaign_title.data
campaign.thumbnail_url = form_campaign_info.thumbnail_url.data
campaign.confirmation_message = form_confirmation_message.confirmation_message.data
campaign.vanity_url = urlify(campaign.title)
for i_reward in campaign.rewards:
i_reward.is_active = False
for idx, reward_forms in enumerate(draft_data["form_rewards"]):
form_reward = CampaignRewardForm.from_json(reward_forms)
current_reward = None
for i_reward in campaign.rewards:
if str(i_reward.id).lower() == str(
form_reward.id.data).lower():
current_reward = i_reward
i_reward.is_active = True
break
if current_reward != None:
pass
else:
current_reward = Reward()
current_reward.claimed = 0
current_reward.id = form_reward.id.data
campaign.rewards.append(current_reward)
current_reward.ordinal = idx
current_reward.is_featured = form_reward.is_featured.data
current_reward.title = form_reward.name.data
current_reward.inventory = form_reward.quantity.data if form_reward.quantity.data else 0
current_reward.cost = form_reward.dollar_amount.data
current_reward.thumbnail_url = form_reward.thumbnail_url.data
current_reward.description = form_reward.description.data
current_reward.delivery_date = form_reward.delivery_date.data
current_reward.is_shipping_required = form_reward.shipping_required.data
current_reward.is_limited_quantity = form_reward.limited_quantity.data
current_reward.international_shipping_fee = form_reward.international_shipping_fee.data if form_reward.international_shipping_fee.data else 0
current_reward.shipping_fee = form_reward.shipping_fee.data if form_reward.shipping_fee.data else 0
if campaign.bonus_reward == None:
campaign.bonus_reward = Reward()
campaign.bonus_reward.campaign = campaign
campaign.bonus_reward.claimed = 0
campaign.bonus_reward.referrals_needed = form_bonus_reward.referrals_needed.data
campaign.bonus_reward.title = form_bonus_reward.name.data
campaign.bonus_reward.inventory = form_bonus_reward.quantity.data if form_bonus_reward.quantity.data else 0
campaign.bonus_reward.cost = 0
campaign.bonus_reward.thumbnail_url = form_bonus_reward.thumbnail_url.data
campaign.bonus_reward.description = form_bonus_reward.description.data
campaign.bonus_reward.delivery_date = form_bonus_reward.delivery_date.data
campaign.bonus_reward.is_shipping_required = form_bonus_reward.shipping_required.data
campaign.bonus_reward.is_limited_quantity = form_bonus_reward.limited_quantity.data
campaign.bonus_reward.international_shipping_fee = form_bonus_reward.international_shipping_fee.data if form_bonus_reward.international_shipping_fee.data else 0
campaign.bonus_reward.shipping_fee = form_bonus_reward.shipping_fee.data if form_bonus_reward.shipping_fee.data else 0
return campaign
def register():
# if post data exists
if request.method == 'POST':
form = RegistrationForm(request.form)
if form.validate():
usernm = form.username.data
pw = form.password.data
verify = form.verify.data
email = form.email.data
userquery = User.query.filter_by(username=usernm.lower()).first()
emailquery = User.query.filter_by(email=email.lower()).first()
# if query returns a user or email address from database, check if it matches post data
if userquery != None:
# convert name data from POST to lowercase and check vs database (name also in lowercase)
if usernm.lower() == userquery.username:
#flash("Username is already in use. Please choose another.")
form.username.errors.append(
"Username is already in use. Please choose another.")
return render_template('front.html',
regform=form,
loginform=LoginForm(),
containerclass="frontcontainer")
if emailquery != None:
if email.lower() == emailquery.email:
form.email.errors.append(
"Email address is already in use. Please use another.")
return render_template('front.html',
regform=form,
loginform=LoginForm(),
containerclass="frontcontainer")
# if query does not return a name, check if form passwords match
elif pw != verify:
#flash("Password doesn't match verification. Please try again.")
form.password.errors.append(
"Password doesn't match verification. Please try again.")
return render_template('front.html',
regform=form,
loginform=LoginForm(),
containerclass="frontcontainer")
# if passwords match, hash the password and store the user in database, username in lowercase
elif pw == verify:
pwhash = generate_password_hash(pw)
newuser = User(usernm.lower(), email.lower(), pwhash)
db.session.add(newuser)
newtask = Task(
"Welcome to List and Reward. Have a free point!", newuser,
None, 1)
db.session.add(newtask)
newreward = Reward("Pat yourself on the back. You deserve it.",
newuser, None, 1)
db.session.add(newreward)
db.session.commit()
msg = Message("L+R Registration Successful",
sender=("List and Reward",
"*****@*****.**"),
recipients=[newuser.email])
msg.body = "Thanks for registering!"
mail.send(msg)
session['userid'] = newuser.id
return redirect(url_for('tasks'))
else:
return render_template('front.html',
regform=form,
loginform=LoginForm(),
containerclass="frontcontainer")
# form view when no POST data
else:
return render_template('front.html',
loginform=LoginForm(),
regform=RegistrationForm(),
containerclass="frontcontainer")
