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;

    }
}
示例#4
0
 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();
 }
示例#5
0
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;
}
示例#6
0
 void operator()(const input_type& _in, output_type& _out)
 {
   _out.clear();
   _out.push_back(_in.front());
   _out.push_back(_in.back());
 }