def history():
loaded_r = request.get_json()
r = json.dumps(loaded_r)
loaded_r = json.loads(r)
token = loaded_r['token']
handle = loaded_r['handle']
action = loaded_r['action']
dnum = loaded_r['dnum']
if db.session.query(Envelope).filter(
Envelope.handle == handle).scalar() == None:
payload = {"error": "Invalid Handle"}
return return_success(payload, False)
result = db.session.query(Envelope).filter(
Envelope.handle == handle).first()
envid = result.envelopeID
if token != None:
if db.session.query(User).filter_by(token=token).scalar() != None:
pass
else:
payload = {"error": "Invalid Token"}
return return_success(payload, False)
result1 = db.session.query(User).filter(User.token == token).first()
history = History(envid, action, result1.userID, dnum)
else:
history = History(envid, action, None, dnum)
db.session.add(history)
db.session.commit()
response = return_success({}, True)
return response
def run_model(epochs, train_db, x_test, path, batchsz, z_dim, my_model, theta,
learn_rate, label):
history = History()
for epoch in range(epochs):
epoch += 1
train_db = train_db.shuffle(batchsz * 5)
for x in train_db:
x = tf.reshape(x, [-1, 784])
with tf.GradientTape() as tape:
kl_div, rec_loss, my_loss, _ = process(x, my_model.L, my_model,
theta)
grads = tape.gradient(my_loss, my_model.trainable_variables)
my_model.opt.apply_gradients(
zip(grads, my_model.trainable_variables))
if epoch % 5 == 0:
# 测试模型
x_0 = random.sample(list(x_test), 100)
x = tf.reshape(x_0, [-1, 784])
kl_div_test, rec_loss_test, my_loss_test, x_hat_logits = process(
x, 1, my_model, theta)
print(
"epoch:{:<3d} (train) KL divergence:{:.2f} reconstruction loss:{:.2f} loss:{:.2f}"
.format(epoch, kl_div, rec_loss, my_loss))
print(
" (test) KL divergence:{:.2f} reconstruction loss:{:.2f} loss:{:.2f}"
.format(kl_div_test, rec_loss_test, my_loss_test))
history.update(kl_div, rec_loss, my_loss, kl_div_test,
rec_loss_test, my_loss_test)
if epoch % 100 == 0:
# 编码解码图片
encode_decode_test(x_0, x_hat_logits, epoch, path)
# 噪音图片测试
#noise_test(x, epoch, path, my_model)
# 用解码器生成图片
generate_picture(epoch, path, batchsz, z_dim, my_model,
my_model.type)
if epoch % 100 == 0:
# 可视化
graph(history, path, z_dim, batchsz, learn_rate, theta, label)
# 存储数据
frame = pd.DataFrame({
'kl_divs':
history.kl_divs,
'the_loss':
history.the_loss,
'the_rec_loss':
history.the_rec_loss,
'kl_divs_tests':
history.kl_divs_tests,
'the_loss_tests':
history.the_loss_tests,
'the_rec_loss_tests':
history.the_rec_loss_tests
})
frame.to_csv('{}Z{} B{} L{} T{} DNN.csv'.format(
path, z_dim, batchsz, learn_rate, theta),
sep=',')
return history
def buy():
buy_form = form.BuyForm()
if buy_form.validate_on_submit():
symbol = buy_form.symbol.data
data = lookup(symbol)
if "error" in data:
return render_template('apologise.html', error=data["error"])
user = User.query.filter_by(username=session['user_name']).first()
for item in user.shares:
if (user.cash - (float(data.get('price')) * buy_form.number.data)) < 0:
return render_template('apologise.html',
error=error.not_enough_cash(buy_form.number.data, symbol.upper()))
if item.symbol == symbol.upper():
item.number += buy_form.number.data
item.total += float(data.get('price')) * buy_form.number.data
user.cash -= float(data.get('price')) * buy_form.number.data
new_history = History(
symbol=item.symbol,
name=item.name,
number=buy_form.number.data,
price=data.get('price'),
total=float(data.get('price')) * buy_form.number.data,
transacted=datetime.datetime.now().strftime('%Y-%m-%d %H:%M'),
status='bought',
owner=user)
db.session.add(new_history)
db.session.commit()
flash('Success')
return redirect(url_for('index'))
new_shares = Share(
symbol=data.get('symbol'),
name=data.get('companyName'),
number=buy_form.number.data,
price=data.get('price'),
total=float(data.get('price')) * buy_form.number.data,
owner=user)
new_history = History(
symbol=new_shares.symbol,
name=new_shares.name,
number=new_shares.number,
price=new_shares.price,
total=new_shares.total,
transacted=datetime.datetime.now().strftime('%Y-%m-%d %H:%M'),
status='bought',
owner=user)
user.cash -= float(data.get('price')) * buy_form.number.data
db.session.add(new_shares, new_history)
db.session.commit()
flash('Success')
return redirect(url_for('index'))
return render_template('buy.html', form=buy_form)
def postenvelope():
loaded_r = request.get_json()
env_name = loaded_r['envelopeName']
rec_name = loaded_r['recipientName']
sender_name = loaded_r['senderName']
all_images = loaded_r['images']
token = loaded_r['token']
j = db.session.query(func.max(Envelope.envelopeID)).scalar()
if j == None:
j = 0
h = hash_envid(j + 1)
else:
h = hash_envid(j + 1)
if token == None:
newenvelope = Envelope(env_name, sender_name, rec_name, h)
newenvelope.eowner = None
history = History(j + 1, 'C', None, None)
db.session.add(history)
db.session.add(newenvelope)
db.session.commit()
else:
if db.session.query(User).filter_by(token=token).scalar() != None:
pass
else:
payload = {"error": "Invalid token"}
return return_success(payload, False)
result = db.session.query(User).filter(User.token == token).first()
newenvelope = Envelope(env_name, sender_name, rec_name, h)
newenvelope.eowner = result.userID
history = History(j + 1, 'C', result.userID, None)
db.session.add(history)
db.session.add(newenvelope)
db.session.commit()
try:
for i in range(len(all_images)):
curr_dict = all_images[i]
b = curr_dict['url']
c = curr_dict['filename']
image = Image(str(j + 1), b, c)
db.session.add(image)
db.session.commit()
except Exception as e:
raise e
loaded_r['handle'] = h
return return_success(loaded_r, True)
def handle_rental(prod_id):
""" Processes a rental. Create associated History object and marks the
product as unavailable so it doesn't show up in future search results
until the owner actively relists it.
"""
user = User.query.filter(User.email == session['user']).one()
product = Product.query.get(prod_id)
cost = product.price_per_day * session['num_days']
history = History(prod_id=prod_id,
renter_user_id=user.user_id,
start_date=session['search_start_date'],
end_date=session['search_end_date'],
total_cost=cost)
product.available = False
db.session.add(history)
db.session.commit()
flash(
"Rental finalized! Check your account page under \"Items Rented\" for info."
)
return redirect('/account-info')
def sell():
sell_form = form.SellForm()
user = User.query.filter_by(username=session['user_name']).first()
if sell_form.validate_on_submit():
symbol = request.form.get('symbol')
if not symbol:
return render_template('apologise.html', error=error.symbol_error())
data = look_price(symbol)
for item in user.shares:
if item.symbol == symbol.upper():
if item.number - sell_form.number.data < 0:
return render_template('apologise.html', error=error.not_enough_shares())
item.number -= sell_form.number.data
item.total -= float(data.get('price')) * sell_form.number.data
user.cash += float(data.get('price')) * sell_form.number.data
new_history = History(
symbol=item.symbol,
name=item.name,
number=sell_form.number.data,
price=data.get('price'),
total=float(data.get('price')) * sell_form.number.data,
transacted=datetime.datetime.now().strftime('%Y-%m-%d %H:%M'),
status='sold',
owner=user)
db.session.add(new_history)
db.session.commit()
if item.number == 0:
Share.query.filter(Share.symbol == item.symbol).delete()
db.session.commit()
flash('Success')
return redirect(url_for('index'))
return render_template('sell.html', form=sell_form, choice=user.shares)
def log(self, vnode_name, action):
global workercinfo
global laststopcpuval
res = VNode.query.filter_by(name=vnode_name).first()
if res is None:
vnode = VNode(vnode_name)
vnode.histories = []
db.session.add(vnode)
db.session.commit()
vnode = VNode.query.get(vnode_name)
billing = 0
cputime = 0
runtime = 0
try:
owner = get_owner(vnode_name)
billing = int(workercinfo[vnode_name]['basic_info']['billing'])
cputime = float(workercinfo[vnode_name]['cpu_use']['val'])
runtime = float(
workercinfo[vnode_name]['basic_info']['RunningTime'])
except Exception as err:
#print(traceback.format_exc())
billing = 0
cputime = 0.0
runtime = 0
history = History(action, runtime, cputime, billing)
vnode.histories.append(history)
if action == 'Stop' or action == 'Create':
laststopcpuval[vnode_name] = cputime
vnode.laststopcpuval = cputime
laststopruntime[vnode_name] = runtime
vnode.laststopruntime = runtime
db.session.add(history)
db.session.commit()
def main():
ATM(
menu,
Accounts(
Table(
File('accounts.txt')
)
),
History(
Table(
File('transactions.txt')
)
)
).start()
def load_histories():
"""Load history data"""
print "Histories"
History.query.delete()
for row in open("data/historiesdata"):
row = row.strip()
row = row.split("|")
product = int(row[0])
renter = int(row[1])
rental_submit_date = row[2]
rental_start_date = row[3]
rental_end_date = row[4]
cost = float(row[5])
try:
owner_rate = int(row[6])
except ValueError:
owner_rate = None
try:
renter_rate = int(row[7])
except ValueError:
renter_rate = None
try:
prod_rate = int(row[8])
except ValueError:
prod_rate = None
rental_submit_date = datetime.strptime(rental_submit_date, "%Y-%m-%d")
rental_start_date = datetime.strptime(rental_start_date, "%Y-%m-%d")
rental_end_date = datetime.strptime(rental_end_date, "%Y-%m-%d")
a = History(prod_id=product,
renter_user_id=renter,
rental_submission_date=rental_submit_date,
start_date=rental_start_date,
end_date=rental_end_date,
total_cost=cost,
owner_rating_id=owner_rate,
renter_rating_id=renter_rate,
prod_rating_id=prod_rate)
db.session.add(a)
db.session.commit()
def get_modbus_value():
try:
rows = ModbusInfo.query.all()
for row in rows:
raw_modbus_value = round(
GemsModbus.read_device_map(row.slave, row.map_address) * 2.2,
2) #0.01 * 220v
#Insert History Data
job_query = History(point_id=row.point_id, value=raw_modbus_value)
db.session.add(job_query)
db.session.commit()
return jsonify(success=True)
except Exception as e:
nw_logging._LOGGER.error(e)
#print(e)
return jsonify({'error': 'get Modbus Value'}), 500
def update_board(request):
if 'game' not in request.session:
return NO_GAME_OBJECT_ERROR
game = request.session['game']
if 'history' not in request.session:
request.session['history'] = History()
history = request.session['history']
print 'Update game board...'
index = int(request.params['index'])
print game.id() #for DEBUG
game.update_board(index)
game.check_winner()
request.session['game'] = game
if game.is_finished():
print "Save to history..."
history.add(game)
request.session['history'] = history
return game.toJSON()
def handle_chat_event(message):
print('Inside handle_chat_event --> message: ', message)
username = message['username']
recipient = message['recipient']
data = message['data']
try:
recipient_user = User.objects.get({'username': recipient})
if recipient_user:
History(username, recipient, data).save()
emit('response', {
'data': data,
'sender': username
},
room=recipient_user.current_sid)
else:
emit('response',
{'data': 'User ' + recipient + ' is not Available'},
room=request.sid)
except DoesNotExist as err:
print('handle_chat_event --> Recipient does not exists: ', recipient,
' -->', err)
emit('response', {'data': 'User ' + recipient + ' does not Exist\'s'},
room=request.sid)
data_x, data_y = load_data('train.csv', 'train')
valid_x, valid_y = data_x[:v], data_y[:v]
data1_x, data1_y = data_x[v:r], data_y[v:r]
data2_x, data2_y = data_x[r:], data_y[r:]
datagen = ImageDataGenerator(
#rescale = 1 / 255,
#zca_whitening = True,
rotation_range=3,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1,
horizontal_flip=True)
datagen.fit(data1_x)
history1 = History()
model = build_model()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit_generator(
datagen.flow(data1_x, data1_y, batch_size=128),
steps_per_epoch=len(data1_x) / 128 * 4,
#steps_per_epoch = 1,
epochs=50,
validation_data=(valid_x, valid_y),
callbacks=[history1])
#model.fit(data1_x, data1_y, batch_size = 128, epochs = 100, validation_data = (valid_x, valid_y), callbacks = [history1])
model.save('self_model')
history1.save('history1')
def main():
""" Main function """
parser = ArgumentParser()
parser.add_argument('--dnn', action='store_true', help='Use DNN model')
parser.add_argument('--dnn_w_info',
action='store_true',
help='Use DNN with info model')
parser.add_argument('--normal',
action='store_true',
help='Normalize ratings')
parser.add_argument('--dim',
type=int,
default=128,
help='Specify latent dimensions')
args = parser.parse_args()
# read training data
ratings_df = pd.read_csv(os.path.join(BASE_DIR, 'data/train.csv'), sep=',')
print("{:d} ratings loaded".format(len(ratings_df)))
# get userIDs, movieIDs and ratings
# -1 is for having a zero base index
users = ratings_df['UserID'].values - 1
print("Users: {:s}, shape = {:s}".format(str(users), str(users.shape)))
movies = ratings_df['MovieID'].values - 1
print("Movies: {:s}, shape = {:s}".format(str(movies), str(movies.shape)))
ratings = ratings_df['Rating'].values
print("Ratings: {:s}, shape = {:s}".format(str(ratings),
str(ratings.shape)))
# read user and movie information
# they can be used as additional features
users_df = pd.read_csv(os.path.join(BASE_DIR, 'data/users.csv'),
engine='python')
users_age = (users_df['Age'] - np.mean(users_df['Age'])) / np.std(
users_df['Age'])
movies_df = pd.read_csv(os.path.join(BASE_DIR, 'data/movies.csv'),
engine='python')
# get all genres of movies to get one hot representation of them later
all_genres = np.array([])
for genres in movies_df['Genres']:
for genre in genres.split('|'):
all_genres = np.append(all_genres, genre)
all_genres = np.unique(all_genres)
# initiate user and movie additional features
max_user_id = ratings_df['UserID'].drop_duplicates().max()
max_movie_id = ratings_df['MovieID'].drop_duplicates().max()
users_info = np.zeros((max_user_id, 23))
movies_info = np.zeros((max_movie_id, all_genres.shape[0]))
# concat gender, occupation --> features with dimension = 23
for idx, user_id in enumerate(users_df['UserID']):
gender = 1 if users_df['Gender'][idx] == 'M' else 0
occu = np.zeros(np.max(np.unique(users_df['Occupation'])) + 1)
occu[users_df['Occupation'][idx]] = 1
tmp = [gender, users_age[idx]]
tmp.extend(occu)
users_info[user_id - 1] = tmp
# get one hot representation of genres --> features with dimension = 19
for idx, movie_id in enumerate(movies_df['movieID']):
genres = movies_df['Genres'][idx].split('|')
tmp = np.zeros(all_genres.shape[0])
for genre in genres:
tmp[np.where(all_genres == genre)[0][0]] = 1
movies_info[movie_id - 1] = tmp
# normalize ratings (This will improve the result of pure matrix factorization)
if args.normal:
mean = np.mean(ratings)
std = np.std(ratings)
ratings = (ratings - mean) / std
# build different models
# we used the same loss and optimizer for three models
if args.dnn:
model = build_model(max_user_id, max_movie_id, args.dim, 'dnn',
users_info, movies_info)
model.compile(loss='mse', optimizer='adam')
model_name = os.path.join(MODEL_DIR, "dnn_model_e{epoch:02d}.hdf5")
elif args.dnn_w_info:
model = build_model(max_user_id, max_movie_id, args.dim,
'dnn_with_info', users_info, movies_info)
model.compile(loss='mse', optimizer='adam')
model_name = os.path.join(MODEL_DIR,
"dnn_w_info_model_e{epoch:02d}.hdf5")
else:
model = build_model(max_user_id, max_movie_id, args.dim, 'mf',
users_info, movies_info)
model.compile(loss='mse', optimizer='adam')
model_name = os.path.join(MODEL_DIR, "mf_model_e{epoch:02d}.hdf5")
# print model information
model.summary()
# setup training checkpoint
# it will save the best model in terms of validation loss
checkpoint = ModelCheckpoint(model_name,
monitor='val_loss',
verbose=0,
save_best_only=True,
mode='min')
# class that handles saving of training and validation loss
history = History()
callbacks_list = [checkpoint, history]
# split data into training and validation set
indices = np.random.permutation(users.shape[0])
val_num = int(users.shape[0] * VALIDATION_SPLIT)
users = users[indices]
movies = movies[indices]
ratings = ratings[indices]
tra_users = users[:-val_num]
tra_movies = movies[:-val_num]
tra_ratings = ratings[:-val_num]
val_users = users[-val_num:]
val_movies = movies[-val_num:]
val_ratings = ratings[-val_num:]
# train the model
model.fit([tra_users, tra_movies],
tra_ratings,
batch_size=256,
epochs=100,
validation_data=([val_users, val_movies], val_ratings),
callbacks=callbacks_list)
# save loss history to files
dump_history(LOG_DIR, history)
def main():
print("#######")
print("WARNING: All rewards are clipped or normalized so you need to use a monitor (see envs.py) or visdom plot to get true rewards")
print("#######")
os.environ['OMP_NUM_THREADS'] = '1'
#os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
#os.environ['CUDA_VISIBLE_DEVICES'] = "9"
if args.vis:
from visdom import Visdom
viz = Visdom(port=args.port)
win = None
envs = [make_env(args.env_name, args.seed, i, args.log_dir, args.add_timestep)
for i in range(args.num_processes)]
if args.num_processes > 1:
envs = SubprocVecEnv(envs)
else:
envs = DummyVecEnv(envs)
if len(envs.observation_space.shape) == 1:
envs = VecNormalize(envs)
obs_shape = envs.observation_space.shape
obs_shape = (obs_shape[0] * args.num_stack, *obs_shape[1:])
if len(envs.observation_space.shape) == 3:
actor_critic = CNNPolicy(obs_shape[0], envs.action_space,args.hid_size, args.feat_size,args.recurrent_policy)
else:
assert not args.recurrent_policy, \
"Recurrent policy is not implemented for the MLP controller"
actor_critic = MLPPolicy(obs_shape[0], envs.action_space)
if envs.action_space.__class__.__name__ == "Discrete":
action_shape = 1
else:
action_shape = envs.action_space.shape[0]
if args.use_cell:
hs = HistoryCell(obs_shape[0], actor_critic.feat_size, 2*actor_critic.hidden_size, 1)
ft = FutureCell(obs_shape[0], actor_critic.feat_size, 2 * actor_critic.hidden_size, 1)
else:
hs = History(obs_shape[0], actor_critic.feat_size, actor_critic.hidden_size, 2, 1)
ft = Future(obs_shape[0], actor_critic.feat_size, actor_critic.hidden_size, 2, 1)
if args.cuda:
actor_critic=actor_critic.cuda()
hs = hs.cuda()
ft = ft.cuda()
if args.algo == 'a2c':
agent = algo.A2C_ACKTR(actor_critic, args.value_loss_coef,
args.entropy_coef, lr=args.lr,
eps=args.eps, alpha=args.alpha,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'ppo':
agent = algo.PPO(actor_critic, hs,ft,args.clip_param, args.ppo_epoch, args.num_mini_batch,
args.value_loss_coef, args.entropy_coef, args.hf_loss_coef,ac_lr=args.lr,hs_lr=args.lr,ft_lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm,
num_processes=args.num_processes,
num_steps=args.num_steps,
use_cell=args.use_cell,
lenhs=args.lenhs,lenft=args.lenft,
plan=args.plan,
ac_intv=args.ac_interval,
hs_intv=args.hs_interval,
ft_intv=args.ft_interval
)
elif args.algo == 'acktr':
agent = algo.A2C_ACKTR(actor_critic, args.value_loss_coef,
args.entropy_coef, acktr=True)
rollouts = RolloutStorage(args.num_steps, args.num_processes, obs_shape, envs.action_space, actor_critic.state_size,
feat_size=512)
current_obs = torch.zeros(args.num_processes, *obs_shape)
def update_current_obs(obs):
shape_dim0 = envs.observation_space.shape[0]
obs = torch.from_numpy(obs).float()
if args.num_stack > 1:
current_obs[:, :-shape_dim0] = current_obs[:, shape_dim0:]
current_obs[:, -shape_dim0:] = obs
obs = envs.reset()
update_current_obs(obs)
rollouts.observations[0].copy_(current_obs)
if args.cuda:
current_obs = current_obs.cuda()
rollouts.cuda()
rec_x = []
rec_y = []
file = open('./rec/' + args.env_name + '_' + args.method_name + '.txt', 'w')
hs_info = torch.zeros(args.num_processes, 2 * actor_critic.hidden_size).cuda()
hs_ind = torch.IntTensor(args.num_processes, 1).zero_()
epinfobuf = deque(maxlen=100)
start_time = time.time()
for j in range(num_updates):
print('begin sample, time {}'.format(time.strftime("%Hh %Mm %Ss",
time.gmtime(time.time() - start_time))))
for step in range(args.num_steps):
# Sample actions
with torch.no_grad():
rollouts.feat[step]=actor_critic.get_feat(rollouts.observations[step])
if args.use_cell:
for i in range(args.num_processes):
h = torch.zeros(1, 2 * actor_critic.hid_size).cuda()
c = torch.zeros(1, 2 * actor_critic.hid_size).cuda()
start_ind = max(hs_ind[i],step+1-args.lenhs)
for ind in range(start_ind,step+1):
h,c=hs(rollouts.feat[ind,i].unsqueeze(0),h,c)
hs_info[i,:]=h.view(1,2*actor_critic.hid_size)
del h,c
gc.collect()
else:
for i in range(args.num_processes):
start_ind = max(hs_ind[i], step + 1 - args.lenhs)
hs_info[i,:]=hs(rollouts.feat[start_ind:step+1,i])
hidden_feat=actor_critic.cat(rollouts.feat[step],hs_info)
value, action, action_log_prob, states = actor_critic.act(
hidden_feat,
rollouts.states[step])
cpu_actions = action.data.squeeze(1).cpu().numpy()
# Obser reward and next obs
obs, reward, done, infos = envs.step(cpu_actions)
for info in infos:
maybeepinfo = info.get('episode')
if maybeepinfo:
epinfobuf.extend([maybeepinfo['r']])
reward = torch.from_numpy(np.expand_dims(np.stack(reward), 1)).float()
masks = torch.FloatTensor([[0.0] if done_ else [1.0] for done_ in done])
hs_ind = ((1-masks)*(step+1)+masks*hs_ind.float()).int()
if args.cuda:
masks = masks.cuda()
if current_obs.dim() == 4:
current_obs *= masks.unsqueeze(2).unsqueeze(2)
else:
current_obs *= masks
update_current_obs(obs)
rollouts.insert(current_obs, hs_ind,states.data, action.data, action_log_prob.data, value.data, reward, masks)
with torch.no_grad():
rollouts.feat[-1] = actor_critic.get_feat(rollouts.observations[-1])
if args.use_cell:
for i in range(args.num_processes):
h = torch.zeros(1, 2 * actor_critic.hid_size).cuda()
c = torch.zeros(1, 2 * actor_critic.hid_size).cuda()
start = max(hs_ind[i], step + 1 - args.lenhs)
for ind in range(start, step + 1):
h, c = hs(rollouts.feat[ind, i].unsqueeze(0), h, c)
hs_info[i, :] = h.view(1, 2 * actor_critic.hid_size)
del h,c
else:
for i in range(args.num_processes):
start_ind = max(hs_ind[i], step + 1 - args.lenhs)
hs_info[i, :] = hs(rollouts.feat[start_ind:step + 1, i])
hidden_feat = actor_critic.cat(rollouts.feat[-1],hs_info)
next_value = actor_critic.get_value(hidden_feat).detach()
rollouts.compute_returns(next_value, args.use_gae, args.gamma, args.tau)
rollouts.compute_ft_ind()
print('begin update, time {}'.format(time.strftime("%Hh %Mm %Ss",
time.gmtime(time.time() - start_time))))
value_loss, action_loss, dist_entropy = agent.update(rollouts)
print('end update, time {}'.format(time.strftime("%Hh %Mm %Ss",
time.gmtime(time.time() - start_time))))
rollouts.after_update()
if j % args.save_interval == 0 and args.save_dir != "":
save_path = os.path.join(args.save_dir, args.algo)
try:
os.makedirs(save_path)
except OSError:
pass
# A really ugly way to save a model to CPU
save_model = actor_critic
if args.cuda:
save_model = copy.deepcopy(actor_critic).cpu()
save_model = [save_model,
hasattr(envs, 'ob_rms') and envs.ob_rms or None]
torch.save(save_model, os.path.join(save_path, args.env_name + ".pt"))
if j % args.log_interval == 0:
end = time.time()
total_num_steps = (j + 1) * args.num_processes * args.num_steps
v_mean,v_median,v_min,v_max = safe(epinfobuf)
print("Updates {}, num timesteps {},time {}, FPS {}, mean/median reward {:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}, entropy {:.5f}, value loss {:.5f}, policy loss {:.5f}".
format(j, total_num_steps,
time.strftime("%Hh %Mm %Ss",
time.gmtime(time.time() - start_time)),
int(total_num_steps / (end - start_time)),
v_mean, v_median, v_min, v_max,
dist_entropy,
value_loss, action_loss))
if not (v_mean==np.nan):
rec_x.append(total_num_steps)
rec_y.append(v_mean)
file.write(str(total_num_steps))
file.write(' ')
file.writelines(str(v_mean))
file.write('\n')
if args.vis and j % args.vis_interval == 0:
try:
# Sometimes monitor doesn't properly flush the outputs
win = visdom_plot(viz, win, args.log_dir, args.env_name,
args.algo, args.num_frames)
except IOError:
pass
plot_line(rec_x, rec_y, './imgs/' + args.env_name + '_' + args.method_name + '.png', args.method_name,
args.env_name, args.num_frames)
file.close()
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1,
horizontal_flip=True)
datagen.fit(train_x)
#valid_x, valid_y = load_data('valid', 'train')
#model = load_model('model')
#model.save_weights('weight')
model = build_model()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#model.load_weights('best_w')
history = History()
model.fit_generator(
datagen.flow(train_x, train_y, batch_size=128),
steps_per_epoch=len(train_x) / 128 * 8,
#steps_per_epoch = 1,
epochs=50,
#validation_data = (valid_x, valid_y),
callbacks=[history])
history.save('history')
model.save(model_path)
#model.save_weights('weight')
#print('\nvalid:', model.evaluate(valid_x, valid_y)[1])
exit()
rotation_range = 3,
width_shift_range = 0.1,
height_shift_range = 0.1,
zoom_range = 0.1,
horizontal_flip = True)
datagen.fit(train_x)
valid_x, valid_y = load_data('valid', 'train')
#model = load_model('model')
#model.save_weights('weight')
model = build_dnn_model()
model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
#model.load_weights('best_w')
history = History()
model.fit_generator(
datagen.flow(train_x, train_y, batch_size = 128),
steps_per_epoch = len(train_x) / 128 * 2,
#steps_per_epoch = 1,
epochs = 50,
validation_data = (valid_x, valid_y),
callbacks = [history])
history.save('dnn_history')
#model.save(model_path)
#model.save_weights('weight')
print('\nvalid:', model.evaluate(valid_x, valid_y)[1])
exit()