Exemple #1
0
 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
Exemple #2
0
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
Exemple #3
0
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)
Exemple #4
0
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)
Exemple #5
0
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)
Exemple #6
0
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)
Exemple #7
0
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
Exemple #8
0
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")
Exemple #9
0
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)
Exemple #10
0
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)))