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()