def player_move(self): event_logger.info('USER ' + str(self.player) + ' MINE ' + str(self.name) + ' GOLD ' + str(self.gold_in_mine) + ' OPTIMAL ' \ + str(self.mine_list[self.mine_position].optimal) + ' MOVE ' + str(self.mine_list[self.mine_position].block_position)) self.mine_position += 1 self.current_mine = self.mine_list[self.mine_position] self.current_block = self.current_mine.get_current_block() self.time_remaining -= self.move_cost
def should_stop(user, real_array, digcost, movecost): ycmax = 0.00 cum_array = [] yieldovercost = [] cum_total = 0 stop_here = 0 for r in real_array: cum_total += r cum_array.append(cum_total) for i in range(0, len(cum_array)): yc = round(cum_array[i]/(movecost + ((i+1) * digcost)), 2) yieldovercost.append(yc) for i in range(0, len(yieldovercost)): if yieldovercost[i] >= ycmax: ycmax = yieldovercost[i] stop_here = i mines_s = str(user.mines) life_s = str(user.game_overs) yieldovercost_s = str(yieldovercost) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' YC ' + yieldovercost_s) return stop_here
def ajax_exit(request): user = UserProfile.objects.get(user=request.user) days_s = str(request.session['days']) mine_no_s = str(request.session['mine_no']) mines_s = str(user.mines) life_s = str(user.game_overs) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' DAY ' + days_s + ' MNO ' + mine_no_s + ' EB ' + request.POST['escape']) return HttpResponse(status=200)
def user_login(request): context = RequestContext(request) if request.method == 'POST': username = request.POST['username'] password = request.POST['password'] user = authenticate(username=username, password=password) if user: if user.is_active: login(request, user) request.session['time_remaining'] = 100 request.session['gold'] = 0 request.session['mine_no'] = 0 request.session['days'] = 1 event_logger.info('USER ' + username + ' LOGIN') return HttpResponseRedirect(reverse('game_choice2'), context) else: return HttpResponse("Your Gold Digger account is disabled.") else: print "Invalid login details: {0}, {1}".format(username, password) bad_details = {'bad_details': " -=: Invalid login details supplied. :=-"} user_form = UserForm() profile_form = UserProfileForm() return render_to_response('gold_digger/home.html', {'user_form': user_form, 'profile_form': profile_form, 'bad_details': bad_details}, context) else: current_user = UserProfile.objects.get(user=request.user) scan = current_user.equipment.image.url tool = current_user.tool.image.url vehicle = current_user.vehicle.image.url mod_scan = int(current_user.equipment.modifier)*100 mod_tool = int(current_user.tool.modifier)*100 modt_tool = current_user.tool.time_modifier mod_vehicle = current_user.vehicle.modifier gold = current_user.gold return render_to_response('gold_digger/home.html', {'current_user': current_user, 'scan': scan, 'tool': tool, 'vehicle': vehicle, 'gold': gold, 'mod_scan': mod_scan, 'mod_tool': mod_tool, 'modt_tool': modt_tool, 'mod_vehicle': mod_vehicle}, context)
def game_over(request): context = RequestContext(request) user = UserProfile.objects.get(user=request.user) if user.gold > user.all_time_max_gold: user.all_time_max_gold = user.gold # Updating user values user.gold += request.session['gold'] # user.mines += 1 user.games_played += 1 request.session['days'] += 1 user.all_time_gold += request.session['gold'] user.average = user.all_time_gold/user.mines user.save() request.session['has_mine'] = False request.session['mine_type'] = '' request.session['time_remaining'] = 100 mine_no = (request.session['mine_no'])-1 request.session['mine_no'] = 0 day_gold = request.session['gold'] total_gold = user.gold request.session['gold'] = 0 cost = determine_cost(request.session['location']) gold_s = str(request.session['gold']) total_gold_s = str(total_gold) mines_s = str(user.mines) life_s = str(user.game_overs) mine_no_s = str(request.session['mine_no']) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' END ' + ' MNO ' + mine_no_s + ' CG ' + gold_s + ' TG ' + total_gold_s) if user.gold < 40: return HttpResponseRedirect(reverse('game_over2'), context) return render_to_response('gold_digger/game_over.html', {'day_gold': day_gold, 'total_gold': total_gold, 'mine_no': mine_no, 'cost': cost}, context)
def move(request): context = RequestContext(request) user = UserProfile.objects.get(user=request.user) point_s = str(request.session['pointer'] - 1) if request.session['time_remaining'] <= 0: return HttpResponseRedirect(reverse('game_over'), context) request.session['has_mine'] = False print request.session['has_mine'] request.session['time_remaining'] -= user.vehicle.modifier user.mines += 1 user.save() days_s = str(request.session['days']) mines_s = str(user.mines) life_s = str(user.game_overs) mine_no_s = str(request.session['mine_no']) gold_s = str(user.gold) curr_s = str(request.session['gold']) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' DAY ' + days_s + ' MNO ' + mine_no_s + ' TG ' + gold_s + ' CG ' + curr_s + ' MOVE ' + point_s) return HttpResponseRedirect(reverse('game2'), context)
def train(): """ train model :return: """ model, base_model, seq_step_len = build_model() print('input lengths ', seq_step_len, 'label length', config.max_seq_len) train_dataset = DataLoader(DataMode.Train).load_batch_from_tfrecords() val_dataset = DataLoader(DataMode.Val).load_batch_from_tfrecords() train_summary_writer = tf.summary.create_file_writer( os.path.join(TENSORBOARD_DIR, 'trainLogs')) val_summary_writer = tf.summary.create_file_writer( os.path.join(TENSORBOARD_DIR, 'valLogs')) latest_ckpt = tf.train.latest_checkpoint(CHECKPOINT_DIR) start_epoch = 0 if latest_ckpt: start_epoch = int(latest_ckpt.split('-')[1].split('.')[0]) model.load_weights(latest_ckpt) event_logger.info('model resumed from: {}, start at epoch: {}'.format( latest_ckpt, start_epoch)) else: event_logger.info( 'passing resume since weights not there. training from scratch') def _validation(): """ validate the model's acc :return: loss and acc """ _val_losses = [] _val_accuracy = [] for _batch, _data in enumerate(val_dataset): _images, _labels = _data _input_length = np.array(np.ones(len(_images)) * int(seq_step_len)) _label_length = np.array( np.ones(len(_images)) * config.max_seq_len) _loss = model.evaluate( [_images, _labels, _input_length, _label_length], _labels, verbose=0) _acc = _compute_acc(_images, _labels, _input_length) _val_losses.append(_loss) _val_accuracy.append(_acc) return np.mean(_val_losses), np.mean(_val_accuracy) def _compute_acc(_images, _labels, _input_length): """ :param _images: a batch of images, [samples, w, h, c] :param _labels: :param _input_length: :return: acc """ _y_pred = base_model.predict_on_batch(x=_images) # print(_y_pred) # (64, 9, 37) _decoded_dense, _ = ctc_decode( _y_pred, _input_length, greedy=config.ctc_greedy, beam_width=config.beam_width, top_paths=config.top_paths, merge_repeated=config.decode_merge_repeated) _error_count = 0 for pred, real in zip(_decoded_dense[0], _labels): str_real = ''.join([config.characters[x] for x in real if x != -1]) str_pred = ''.join([config.characters[x] for x in pred if x != -1]) # print(str_real, str_pred) if str_pred != str_real: _error_count += 1 _acc = (len(_labels) - _error_count) / len(_labels) return _acc # start training progress for epoch in range(start_epoch, config.epochs): train_acc_avg = [] train_loss_avg = [] start = time.time() for batch, data in enumerate(train_dataset): images, labels = data input_length = np.array(np.ones(len(images)) * int(seq_step_len)) label_length = np.array(np.ones(len(images)) * config.max_seq_len) train_loss = model.train_on_batch( x=[images, labels, input_length, label_length], y=labels) train_acc = _compute_acc(images, labels, input_length) train_acc_avg.append(train_acc) train_loss_avg.append(train_loss) train_loss = np.mean(train_loss_avg) train_acc = np.mean(train_acc_avg) val_loss, val_acc = _validation() # write train and val logs with train_summary_writer.as_default(): tf.summary.scalar('loss', train_loss, step=epoch) tf.summary.scalar('acc', train_acc, step=epoch) with val_summary_writer.as_default(): tf.summary.scalar('loss', val_loss, step=epoch) tf.summary.scalar('acc', val_acc, step=epoch) print( 'Epoch: [{epoch}/{epochs}], train_loss: {train_loss}, train_acc: {train_acc}, ' 'val_loss: {val_loss}, val_acc: {val_acc}, ' 'one epoch costs time: {time} s, learning rate: {lr}'.format( epoch=epoch + 1, epochs=config.epochs, train_loss=train_loss, train_acc=train_acc, val_loss=val_loss, val_acc=val_acc, time=time.time() - start, lr=config.lr)) ckpt_path = os.path.join( CHECKPOINT_DIR, '{cnn}&{rnn}-{epoch}'.format(cnn=config.cnn_type, rnn=config.rnn_type, epoch=epoch + 1)) model.save_weights(ckpt_path) if val_acc >= config.end_acc or val_loss <= config.end_cost: # tf.saved_model.save(base_model, os.path.join(SVAED_MODEL_DIR, '{name}_model.h5'.format(name=config.dataset))) base_model.save( os.path.join(SVAED_MODEL_DIR, '{name}_model.h5'.format(name=config.dataset))) break
def ajax_upgrade(request): user = UserProfile.objects.get(user=request.user) item_type = request.POST['up'] mines_s = str(user.mines) if item_type == 'scan': item_id = user.equipment.id myResponse = {} myResponse['maxed_up'] = False myResponse['funds'] = False if item_id == 5: myResponse['maxed_up'] = True return HttpResponse(json.dumps(myResponse), content_type="application/json") else: item_id += 1 new_item = ScanningEquipment.objects.get(id=item_id) if new_item.price > user.gold: return HttpResponse(status=204) if (user.gold - new_item.price) < 40: return HttpResponse(status=202) else: user.gold -= new_item.price user.equipment = new_item user.save() myResponse['image'] = new_item.image.url myResponse['gold'] = user.gold # logging days_s = str(request.session['days']) total_gold_s = str(user.gold) life_s = str(user.game_overs) mine_no_s = str(request.session['mine_no']) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' MNO ' + mine_no_s + ' DAY ' + days_s + ' BUY ' + new_item.name + ' TG ' + total_gold_s) return HttpResponse(json.dumps(myResponse), content_type="application/json") if item_type == 'tool': item_id = user.tool.id myResponse = {} myResponse['maxed_up'] = False myResponse['funds'] = False if item_id == 5: myResponse['maxed_up'] = True return HttpResponse(json.dumps(myResponse), content_type="application/json") else: item_id += 1 new_item = DiggingEquipment.objects.get(id=item_id) if new_item.price > user.gold: return HttpResponse(status=204) if (user.gold - new_item.price) < 40: return HttpResponse(status=202) else: user.gold -= new_item.price user.tool = new_item user.save() myResponse['image'] = new_item.image.url myResponse['gold'] = user.gold # logging days_s = str(request.session['days']) total_gold_s = str(user.gold) life_s = str(user.game_overs) mine_no_s = str(request.session['mine_no']) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' MNO ' + mine_no_s + ' DAY ' + days_s + ' BUY ' + new_item.name + ' TG ' + total_gold_s) return HttpResponse(json.dumps(myResponse), content_type="application/json") if item_type == 'vehicle': item_id = user.vehicle.id myResponse = {} myResponse['maxed_up'] = False if item_id == 5: myResponse['maxed_up'] = True return HttpResponse(json.dumps(myResponse), content_type="application/json") else: item_id += 1 new_item = Vehicle.objects.get(id=item_id) if new_item.price > user.gold: return HttpResponse(status=204) if (user.gold - new_item.price) < 40: return HttpResponse(status=202) else: user.gold -= new_item.price user.vehicle = new_item user.save() myResponse['image'] = new_item.image.url myResponse['gold'] = user.gold # logging days_s = str(request.session['days']) total_gold_s = str(user.gold) life_s = str(user.game_overs) mine_no_s = str(request.session['mine_no']) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' MNO ' + mine_no_s + ' DAY ' + days_s + ' BUY ' + new_item.name + ' TG ' + total_gold_s) return HttpResponse(json.dumps(myResponse), content_type="application/json")
def game2(request): context = RequestContext(request) user = UserProfile.objects.get(user=request.user) days_s = str(request.session['days']) if request.session['mine_type'] == '': mine_type = request.session['location'] user.gold -= determine_cost(mine_type) user.save() mines_s = str(user.mines) life_s = str(user.game_overs) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' DAY ' + days_s + ' NLOC ' + mine_type + ' SCAN ' + user.equipment.name + ' DIG ' + user.tool.name + ' VEHICLE ' + user.vehicle.name) else: mine_type = request.session['mine_type'] mine_no_s = str(request.session['mine_no']) mines_s = str(user.mines) life_s = str(user.game_overs) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' DAY ' + days_s + ' LOC ' + mine_type + ' MNO ' + mine_no_s) if not request.session['has_mine']: gen = yieldgen.YieldGenerator # Randomising the max amount of gold up_boundary = 50 down_boundary = 40 max_gold = random.randint(down_boundary, up_boundary) limits = divide(max_gold) pickled_limits = pickle.dumps(limits) request.session['limits'] = pickled_limits request.session['mine_no'] += 1 time_remaining = request.session['time_remaining'] if mine_type == 'California': print "California" request.session['mine_type'] = 'California' gen = yieldgen.CaliforniaQuadraticYieldGenerator(depth=10, max=max_gold, min=0) elif mine_type == 'Yukon': print "Yukon" request.session['mine_type'] = "Yukon" gen = yieldgen.YukonQuadraticYieldGenerator(depth=10, max=max_gold, min=0) elif mine_type == 'Brazil': print "Brazil" request.session['mine_type'] = 'Brazil' gen = yieldgen.BrazilQuadraticYieldGenerator(depth=10, max=max_gold, min=0) elif mine_type == 'South Africa': print "South Africaaaaaaaaaaaaaaaaaaaaaaaa" request.session['mine_type'] = 'South Africa' gen = yieldgen.SouthAfricaQuadraticYieldGenerator(depth=10, max=max_gold, min=0) elif mine_type == 'Scotland': print "Scotland" request.session['mine_type'] = 'Scotland' gen = yieldgen.ScotlandQuadraticYieldGenerator(depth=10, max=max_gold, min=0) elif mine_type == 'Victoria': print "Victoria" request.session['mine_type'] = 'Victoria' gen = yieldgen.VictoriaQuadraticYieldGenerator(depth=10, max=max_gold, min=0) else: print "Faaaaaiiilllll" accuracy = user.equipment.modifier m = mine.Mine(gen, accuracy, user) blocks = m.blocks real_array = [] for b in blocks: a = round(b.gold*user.tool.modifier) real_array.append(a) real_array_s = str(real_array) mine_no_s = str(request.session['mine_no']) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' MNO ' + mine_no_s + ' RMY ' + real_array_s) digcost = user.tool.time_modifier move_cost = user.vehicle.modifier digcost_s = str(digcost) move_cost_s = str(move_cost) gold_s = str(user.gold) should_stop_s = str(should_stop(user, real_array, digcost, move_cost)) curr_s = str(request.session['gold']) event_logger.info('USER ' + user.user.username + ' LIFE ' + life_s + ' TOT ' + mines_s + ' MNO ' + mine_no_s + ' TG ' + gold_s + ' CG ' + curr_s + ' DIGC ' + digcost_s + ' MOC ' + move_cost_s + ' SMOVE ' + should_stop_s) request.session['has_mine'] = True request.session['pointer'] = 0 scaffold = [1, 2, 3] # Pickling pickled_blocks = pickle.dumps(blocks) request.session['pickle'] = pickled_blocks move_cost = user.vehicle.modifier dig_cost = user.tool.time_modifier location = request.session['location'] pointer = request.session['pointer'] mine_no = request.session['mine_no'] visibility = int(user.equipment.modifier*10) mod_scan = int(user.equipment.modifier*100) mod_tool = int(user.tool.modifier*100) modt_tool = user.tool.time_modifier mod_vehicle = user.vehicle.modifier if time_remaining < 0: return HttpResponseRedirect(reverse('game_over'), context) return render_to_response('gold_digger/game2.html', {'blocks': blocks, 'user': user, 'time_remaining': time_remaining, 'limits': limits, 'scaffold': scaffold, 'move_cost': move_cost, 'dig_cost': dig_cost, 'location': location, 'pointer': pointer, 'mine_no': mine_no, 'visibility': visibility, 'mod_scan': mod_scan, 'mod_tool': mod_tool, 'modt_tool': modt_tool, 'mod_vehicle': mod_vehicle}, context) else: # Unpickling pickled_blocks = request.session['pickle'] blocks = pickle.loads(pickled_blocks) pickled_limits = request.session['limits'] limits = pickle.loads(pickled_limits) move_cost = user.vehicle.modifier dig_cost = user.tool.time_modifier location = request.session['location'] time_remaining = request.session['time_remaining'] pointer = request.session['pointer'] mine_no = request.session['mine_no'] visibility = int((user.equipment.modifier) * 10) mod_scan = int(user.equipment.modifier * 100) mod_tool = int(user.tool.modifier * 100) modt_tool = user.tool.time_modifier mod_vehicle = user.vehicle.modifier scaffold = [1, 2, 3] if time_remaining < 0: return HttpResponseRedirect(reverse('game_over'), context) return render_to_response('gold_digger/game2.html', {'blocks': blocks, 'user': user, 'time_remaining': time_remaining, 'limits': limits, 'scaffold': scaffold, 'move_cost': move_cost, 'dig_cost': dig_cost, 'location': location, 'pointer': pointer, 'mine_no': mine_no, 'visibility': visibility, 'mod_scan': mod_scan, 'mod_tool': mod_tool, 'modt_tool': modt_tool, 'mod_vehicle': mod_vehicle}, context)
def train(): """ train model :return: """ model, base_model, seq_step_len = build_model() print('seq_step_len ', seq_step_len) train_dataset = DataLoader(DataMode.Train).load_batch_from_tfrecords() val_dataset = DataLoader(DataMode.Val).load_batch_from_tfrecords() latest_ckpt = tf.train.latest_checkpoint(CHECKPOINT_DIR) start_epoch = 0 if latest_ckpt: start_epoch = int(latest_ckpt.split('-')[1].split('.')[0]) print('start epoch at ', start_epoch) model.load_weights(latest_ckpt) event_logger.info('model resumed from: {}, start at epoch: {}'.format(latest_ckpt, start_epoch)) else: event_logger.info('passing resume since weights not there. training from scratch') def _validation(): """ validate the model's acc :return: acc """ _val_losses = [] _val_accuracy = [] for _batch, _data in enumerate(val_dataset): _images, _labels = _data _input_length = np.array(np.ones(len(_images)) * int(seq_step_len)) _label_length = np.array(np.ones(len(_images)) * config.max_seq_len) _loss = model.evaluate([_images, _labels, _input_length, _label_length], _labels, verbose=0) _acc = _compute_acc(_images, _labels, _input_length) _val_losses.append(_loss) _val_accuracy.append(_acc) return np.mean(_val_losses), np.mean(_val_accuracy) def _compute_acc(_images, _labels, _input_length): """ :param _images: a batch of image, [samples, w, h, c] :param _labels: :param _input_length: :return: acc """ _y_pred = base_model.predict_on_batch(x=_images) # print(_y_pred) # (64, 9, 37) _decoded_dense, _ = tf.keras.backend.ctc_decode(_y_pred, _input_length, greedy=True, beam_width=5, top_paths=1) _error_count = 0 for pred, real in zip(_decoded_dense[0], _labels): str_real = ''.join([config.characters[x] for x in real if x != -1]) str_pred = ''.join([config.characters[x] for x in pred if x != -1]) # print(str_real, str_pred) if str_pred != str_real: _error_count += 1 _acc = (len(_labels) - _error_count) / len(_labels) return _acc # start training progress for epoch in range(start_epoch, config.epochs): for batch, data in enumerate(train_dataset): images, labels = data input_length = np.array(np.ones(len(images)) * int(seq_step_len)) label_length = np.array(np.ones(len(images)) * config.max_seq_len) train_loss = model.train_on_batch(x=[images, labels, input_length, label_length], y=labels) # logging result every 10-batch. (about 10 * batch_size images) if batch % 10 == 0: train_acc = _compute_acc(images, labels, input_length) val_loss, val_acc = _validation() print('Epoch: [{epoch}/{epochs}], iter: {batch}, train_loss: {train_loss}, train_acc: {train_acc}, ' 'val_loss: {val_loss}, val_acc: {val_acc}'.format(epoch=epoch + 1, epochs=config.epochs, batch=batch, train_loss=train_loss, train_acc=train_acc, val_loss=val_loss, val_acc=val_acc)) ckpt_path = os.path.join(CHECKPOINT_DIR, 'CRNNORC-{epoch}'.format(epoch=epoch + 1)) model.save_weights(ckpt_path) base_model.save(os.path.join(SVAED_MODEL_DIR, '{}_model.h5'.format(config.dataset)))