jubatus::core::burst Namespace Reference

Classes
class	aggregator
class	basic_window
struct	batch_input
struct	batch_result
class	burst
struct	burst_options
class	burst_result
class	input_window
class	intersection_helper
struct	keyword_params
struct	keyword_with_params
class	result_storage
class	result_window

Typedefs
typedef framework::linear_mixable_helper< burst, burst::diff_t >	mixable_burst

Functions
void	burst_detect (const std::vector< uint32_t > &d_vector, const std::vector< uint32_t > &r_vector, std::vector< double > &batch_weights, double scaling_param, double gamma, double burst_cut_threshold)
template<class W1 , class W2 >
std::pair< int, int >	get_intersection (const W1 &w1, const W2 &w2)
bool	window_position_near (double pos0, double pos1, double batch_interval)

Variables
const std::vector< batch_result >	empty_batch_results
int	survival_mix_count_from_set_unprocessed = 5

Typedef Documentation

typedef framework::linear_mixable_helper<burst, burst::diff_t> jubatus::core::burst::mixable_burst

Definition at line 129 of file burst.hpp.

Function Documentation

void jubatus::core::burst::burst_detect	(	const std::vector< uint32_t > &	d_vector,
		const std::vector< uint32_t > &	r_vector,
		std::vector< double > &	batch_weights,
		double	scaling_param,
		double	gamma,
		double	burst_cut_threshold
	)

Definition at line 159 of file engine.cpp.

References JUBATUS_EXCEPTION.

Referenced by jubatus::core::burst::burst_result::burst_result().

                                              {
  const int window_size = d_vector.size();
  if (gamma <= 0) {
    throw JUBATUS_EXCEPTION(
        common::invalid_parameter("gamma must be > 0."));
  }
  if (scaling_param <= 1) {
    throw JUBATUS_EXCEPTION(
        common::invalid_parameter("scaling_param must be > 1."));
  }
  if (burst_cut_threshold <= 0) {
    throw JUBATUS_EXCEPTION(
        common::invalid_parameter("burst_cut_threshold must be > 0."));
  }
  if (d_vector.size() != r_vector.size()) {
    throw JUBATUS_EXCEPTION(
        common::invalid_parameter("d_vector.size() != r_vector.size()"));
  }
  for (int batch_id = 0; batch_id < window_size; batch_id++) {
    if (d_vector[batch_id] < r_vector[batch_id]) {
      throw JUBATUS_EXCEPTION(
          common::invalid_parameter(
            "d_vector[batch_id] < r_vector[batch_id]"));
    }
  }
  const std::vector<double> p_vector
    = get_p_vector(d_vector, r_vector, scaling_param);

  erase_uncalc_batches(batch_weights);

  // exception handling of
  // - "p_{burst_state} > 1"
  // - "p_{base_state} = 0"
  if (1 < p_vector[kBurstState]) {
    batch_weights.resize(window_size, INFINITY);
    return;
  } else if (p_vector[kBaseState] == 0) {
    batch_weights.resize(window_size, 0);
    return;
  }

  const int reuse_batch_size = batch_weights.size();

  // the optimal costvals
  // - index 0: [1st batch - prev batch] optimal seq -> [now] base
  // - index 1: [1st batch - prev batch] optimal seq -> [now] burst
  double prev_optimal_in_now_states_costs[] = {-1, -1};

  // the optimal costval from 1st batch to previuous batch.
  // - index 0: previous : base
  // - index 1: previous : burst
  // To avoid "burst state in 1st batch",
  // we must set to INFINITY the "cost val of burst state".
  double prev_optimal_costs[] = {0, INFINITY};
  if (batch_weights.size() != 0 && 0 < batch_weights.back()) {
    // To avoid "base state in 1st batch",
    // we must set to INFINITY the "cost val of base state".
    prev_optimal_costs[kBaseState] = INFINITY;
    prev_optimal_costs[kBurstState] = 0;
  }

  // state sequences from 1st batch to now batch.
  // - index 0: [1st batch - prev batch] optimal seq -> [now] base
  // - index 1: [1st batch - prev batch] optimal seq -> [now] burst
  std::vector<std::vector<int> > prev_optimal_in_now_states_seq(kStatesNum);

  // state sequences from 1st batch to previous batch.
  // - index 0: [1st batch - prev batch] optimal seq & [prev] base
  // - index 1: [1st batch - prev batch] optimal seq & [prev] burst
  std::vector<std::vector<int> > prev_optimal_states_seq(kStatesNum);

  for (int update_batch_id = 0;
      update_batch_id < window_size - reuse_batch_size;
      update_batch_id++) {
    for (int now_state = kBaseState; now_state < kStatesNum; now_state++) {
      std::pair<int, double> prev_optimal_pair;

      if ((0 < update_batch_id + reuse_batch_size) &&
         (d_vector[update_batch_id + reuse_batch_size - 1] == 0)) {
        // exception handling
        // in prev batch,
        // (d, r) = (0, 0)
        prev_optimal_pair.first = kBaseState;
        prev_optimal_pair.second =
            prev_optimal_costs[kBaseState] +
            tau(kBaseState, now_state, gamma, window_size);
      } else if (0 < update_batch_id + reuse_batch_size &&
          check_branch_cuttable(d_vector, r_vector, p_vector,
                                update_batch_id + reuse_batch_size - 1,
                                burst_cut_threshold)) {
        prev_optimal_pair.first = kBaseState;
        prev_optimal_pair.second =
            prev_optimal_costs[kBaseState] +
            tau(kBaseState, now_state, gamma, window_size);
      } else {
        prev_optimal_pair =
            calc_previous_optimal_state(now_state,
                                        prev_optimal_costs[kBaseState],
                                        prev_optimal_costs[kBurstState],
                                        gamma, window_size);
      }

      prev_optimal_in_now_states_costs[now_state] =
          prev_optimal_pair.second +
          sigma(p_vector[now_state],
                d_vector[update_batch_id + reuse_batch_size],
                r_vector[update_batch_id + reuse_batch_size]);

      prev_optimal_in_now_states_seq[now_state] =
          prev_optimal_states_seq[prev_optimal_pair.first];
      prev_optimal_in_now_states_seq[now_state].push_back(now_state);
    }

    //
    // ready for precessing the next batch.
    //
    for (int state = kBaseState; state < kStatesNum; state++) {
      prev_optimal_costs[state] = prev_optimal_in_now_states_costs[state];
      prev_optimal_states_seq[state] =
          prev_optimal_in_now_states_seq[state];
    }
  }

  std::vector<int> optimal_states_seq;

  if (d_vector[window_size - 1] == 0) {
    // exception handling
    // in prev batch,
    // (d, r) = (0, 0)
    optimal_states_seq = prev_optimal_in_now_states_seq[kBaseState];
  } else if (check_branch_cuttable(d_vector, r_vector, p_vector,
                                  window_size - 1,
                                  burst_cut_threshold)) {
    optimal_states_seq = prev_optimal_in_now_states_seq[kBaseState];
  } else {
    optimal_states_seq =
        prev_optimal_in_now_states_costs[kBaseState] <=
            prev_optimal_in_now_states_costs[kBurstState] ?
          prev_optimal_in_now_states_seq[kBaseState] :
          prev_optimal_in_now_states_seq[kBurstState];
  }

  //
  // calculation of batch_weights
  //

  // reuse of past results
  for (int batch_id = 0; batch_id < reuse_batch_size; batch_id++) {
    if (0 < batch_weights[batch_id]) {
      batch_weights[batch_id] =
          get_batch_weight(d_vector, r_vector, p_vector, batch_id);
    }
  }
  // new calculation
  for (int batch_id = reuse_batch_size; batch_id < window_size; batch_id++) {
    int state = optimal_states_seq[batch_id - reuse_batch_size];
    batch_weights.push_back(state == kBurstState ?
                              get_batch_weight(d_vector, r_vector,
                                               p_vector, batch_id) :
                              0);
  }
}

Here is the caller graph for this function:

template<class W1 , class W2 >

std::pair<int, int> jubatus::core::burst::get_intersection	(	const W1 &	w1,
		const W2 &	w2
	)

Definition at line 118 of file window_intersection.hpp.

References jubatus::core::burst::intersection_helper::get_intersection().

Referenced by jubatus::core::burst::burst_result::burst_result(), jubatus::core::burst::aggregator::impl_::flush_results(), and jubatus::core::burst::aggregator::impl_::make_new_window_().

                                                               {
  return intersection_helper(w1).get_intersection(w2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool jubatus::core::burst::window_position_near ( double  pos0, double  pos1, double  batch_interval  )

inline

Definition at line 35 of file window_intersection.hpp.

Referenced by jubatus::core::burst::burst_result::has_same_start_pos_to(), jubatus::core::burst::burst_result::has_start_pos_newer_than(), jubatus::core::burst::burst_result::has_start_pos_older_than(), and jubatus::core::burst::intersection_helper::position_near().

                                                     {
  return std::abs(pos1 - pos0) / batch_interval < 0.01;
}

Here is the caller graph for this function:

Variable Documentation

const std::vector<batch_result> jubatus::core::burst::empty_batch_results

Definition at line 162 of file burst_result.cpp.

Referenced by jubatus::core::burst::burst_result::get_batches().

int jubatus::core::burst::survival_mix_count_from_set_unprocessed = 5

Definition at line 39 of file burst.cpp.

Referenced by jubatus::core::burst::burst::impl_::aggregate_helper_::set_unprocessed().