double Model::update(input_type & input_data, unsigned data_index)
{
assert(data_index >= 0 && data_index < input_data.size());
unsigned user_index = unsigned(input_data[data_index][0]);
if (user_index > 10){
//return false;
}
unsigned item_index = unsigned(input_data[data_index][1]);
unsigned context_index = unsigned(input_data[data_index][2]);
double actual_value = input_data[data_index][3];
// return actual_value;
double predict_value = compute(input_data, data_index);
// cout << actual_value << ", " << predict_value <<endl;
double error = predict_value - actual_value;
// cout<<"user:\n";
// printVector(_user_model[user_index]);
updateUserModel(error, user_index, item_index, context_index);
// printVector(_user_model[user_index]);
// cout<<"item:\n";
// printVector(_item_model[item_index]);
updateItemModel(error, user_index, item_index, context_index);
// printVector(_item_model[item_index]);
// cout <<"context:\n";
// printVector(_context_model[context_index]);
updateContextModel(error, user_index, item_index, context_index);
// printVector(_context_model_new[context_index]);
updateTensorW(error, user_index, item_index, context_index);
updateTensorZ(error, user_index, item_index, context_index);
updateUserContextPrefer(error, user_index, item_index, context_index);
updateItemContextPrefer(error, user_index, item_index, context_index);
updateSelf(user_index, item_index, context_index);
return error;
}
double Model::compute(input_type & input_data, unsigned data_index)
{
assert(data_index >= 0 && data_index < input_data.size());
unsigned user_index = unsigned(input_data[data_index][0]);
unsigned item_index = unsigned(input_data[data_index][1]);
unsigned context_index = unsigned(input_data[data_index][2]);
assert(user_index >= 0 && item_index >= 0 && context_index >= 0);
assert(user_index < _num_u && item_index < _num_v && context_index < _num_c);
double res = 0.0;
double tmp = 0.0;
tmp = multiply(_user_model[user_index], _item_model[item_index]);
res += tmp;
// cout << "|" << tmp << " | ";
tmp = multiply(_item_context_prefer[item_index],
_user_model[user_index],
_tensor_w,
_context_model[context_index]);
res += tmp;
// cout << tmp << " | ";
tmp = multiply(_user_context_prefer[user_index],
_item_model[item_index],
_tensor_z,
_context_model[context_index]);
res += tmp;
// cout << tmp << "|\n";
return res;
}
bool Model::train(input_type & input_data)
{
cout << _learning_rate <<endl;
cout << _iter_limit <<endl;
for (int t = 0; t < 1; t++) {
for (int i = 0; i < _iter_limit; ++i){
double error_all = 0.0;
unsigned count = 0;
time_t begin_time, end_time;
time(&begin_time);
#pragma omp parallel for
for (int j = 0; j < (input_data.size() / _iter_limit); ++j){
double error = update(input_data, j*_iter_limit+i);
#pragma omp atomic
error_all += error;
#pragma omp atomic
++count;
}
cout << "\r\t\t" << i << "\t";
time(&end_time);
cout << "||| " << error_all / count << " ||| " << difftime(end_time, begin_time) << "s\n";
}
cout << "---------" << t+1 << "-----------" << endl;
}
}
output_type operator()(const input_type& input) const {
double mark = 0;
for(auto m : input)
if(m < pass_mark) return 0;
else mark += m;
return mark/(Mark)input.size();
}
inline void merge_sort(input_type a, input_type b, output_type dest,
size_t a_merge_size, size_t b_merge_size)
{
assert(a_merge_size >= 4);
assert(b_merge_size >= 4);
using simd_type_t = typename input_type::value_type;
auto a_end = a + a_merge_size;
auto b_end = b + b_merge_size;
simd_type_t a1 = *a++;
simd_type_t a2 = *a++;
simd_type_t b1 = *b++;
simd_type_t b2 = *b++;
do {
tie(a1, a2, b1, b2) = bitonic_merge(a1, a2, b1, b2);
*dest++ = a1;
*dest++ = a2;
a1 = b1;
a2 = b2;
// reference the underlying iterator
if ((*a.base()) < (*b.base())) {
b1 = *a++;
b2 = *a++;
} else {
b1 = *b++;
b2 = *b++;
}
} while (a != a_end && b != b_end);
tie(a1, a2, b1, b2) = bitonic_merge(a1, a2, b1, b2);
*dest++ = a1;
*dest++ = a2;
a1 = b1;
a2 = b2;
while (a != a_end) {
b1 = *a++;
b2 = *a++;
tie(a1, a2, b1, b2) = bitonic_merge(a1, a2, b1, b2);
*dest++ = a1;
*dest++ = a2;
a1 = b1;
a2 = b2;
}
while (b != b_end) {
b1 = *b++;
b2 = *b++;
tie(a1, a2, b1, b2) = bitonic_merge(a1, a2, b1, b2);
*dest++ = a1;
*dest++ = a2;
a1 = b1;
a2 = b2;
}
*dest++ = a1;
*dest++ = a2;
}
void operator()(const input_type& _in, output_type& _out)
{
_out.clear();
_out.push_back(_in.front());
_out.push_back(_in.back());
}
