virtual std::vector<size_t> recommend(size_t uid, size_t topk,
const std::unordered_set<size_t>& rated_set) const {
std::unordered_map<size_t, double> topk_rets;
for (auto& rated_iid : rated_set) {
for (auto& item_sim_pair : topk_neighbors_[rated_iid]) {
if (rated_set.count(item_sim_pair.first))
continue;
if (topk_rets.count(item_sim_pair.first)) {
topk_rets[item_sim_pair.first] += item_sim_pair.second;
} else {
topk_rets[item_sim_pair.first] = item_sim_pair.second;
}
}
}
std::vector<std::pair<size_t, double>> ret_pairs(topk_rets.begin(),
topk_rets.end());
size_t topk_star = std::min(topk, ret_pairs.size());
std::partial_sort(ret_pairs.begin(), ret_pairs.begin() + topk_star, ret_pairs.end(),
sort_by_second_desc<size_t, double>);
std::vector<size_t> rets(topk_star);
std::transform(ret_pairs.begin(), ret_pairs.begin() + topk_star,
rets.begin(), [](const std::pair<size_t, double>& p){
return p.first;
});
return std::move(rets);
}
int
main
(
int argc,
char ** argv
)
{
ifstream mf_file("mutual_funds.txt");
ofstream results("results.txt");
string mf;
std::vector<double> rets(8);
int num = 30;
std::vector<mystruct0> rets;
mf = "SPY";
for (unsigned q = 0; q < 8; ++q) {
rets[q] = get_return(
mf,
MARKET_DATA_WEEKLY,
NUM_WEEKS_IN_A_QUARTER,
q*NUM_WEEKS_IN_A_QUARTER);
}
mystruct a(mf, rets);
rets.push_back(a);
print_rets(mf, rets);
try {
while (mf_file.good()) {
getline(mf_file, mf);
if (mf.empty()) break;
for (unsigned q = 0; q < 8; ++q) {
rets[q] = get_return(
mf,
MARKET_DATA_WEEKLY,
NUM_WEEKS_IN_A_QUARTER,
q*NUM_WEEKS_IN_A_QUARTER);
}
print_rets(mf, rets);
if (num-- == 0) break;
}
}
catch (exception e) {
}
mf_file.close();
system("pause");
return 0;
}
string ParseLeafName(string name) const {
string s = "(.+)";
s += "_(\\d*(\\.\\d+)?(e\\+\\d+)?)";
regex re;
re.assign(s,regex_constants::icase);
cmatch c;
if (!regex_match(name.c_str(),c,re)) {
cerr << "error in filetree\n";
cerr << "get leaf node name\n";
cerr << name << '\n';
exit(1);
}
string rets(c[1].first,c[1].second);
return StringReplace('_'," ",rets);
}
static void ParseNativeFunction(FScanner &sc, PClassActor *cls)
{
TArray<PType *> rets(1);
if (sc.LumpNum == -1 || Wads.GetLumpFile(sc.LumpNum) > 0)
{
sc.ScriptMessage ("functions can only be declared by native actors!");
FScriptPosition::ErrorCounter++;
}
// Read the type and make sure it's int or float.
sc.MustGetAnyToken();
switch (sc.TokenType)
{
case TK_Int:
case TK_Bool:
rets.Push(TypeSInt32);
break;
case TK_Float:
rets.Push(TypeFloat64);
break;
case TK_Angle_t:
rets.Push(TypeAngle);
break;
case TK_Fixed_t:
rets.Push(TypeFixed);
break;
case TK_State:
rets.Push(TypeState);
break;
case TK_Identifier:
rets.Push(NewPointer(RUNTIME_CLASS(DObject)));
// Todo: Object type
sc.ScriptError("Object type variables not implemented yet!");
break;
default:
sc.ScriptError("Invalid return type %s", sc.String);
return;
}
sc.MustGetToken(TK_Identifier);
ParseFunctionDef(sc, cls, sc.String, rets, VARF_Method);
}
PFunction *CreateAnonymousFunction(PClass *containingclass, PType *returntype, int flags)
{
TArray<PType *> rets(1);
TArray<PType *> args;
TArray<uint32_t> argflags;
TArray<FName> argnames;
// Functions that only get flagged for actors do not need the additional two context parameters.
int fflags = (flags& (SUF_OVERLAY | SUF_WEAPON | SUF_ITEM)) ? VARF_Action | VARF_Method : VARF_Method;
rets[0] = returntype != nullptr? returntype : TypeError; // Use TypeError as placeholder if we do not know the return type yet.
SetImplicitArgs(&args, &argflags, &argnames, containingclass, fflags, flags);
PFunction *sym = new PFunction(containingclass, NAME_None); // anonymous functions do not have names.
sym->AddVariant(NewPrototype(rets, args), argflags, argnames, nullptr, fflags, flags);
return sym;
}
std::vector<double> evaluate_rec_list(const std::vector<size_t>& list,
const std::unordered_set<size_t>& set) const {
std::vector<double> rets(8, 0.);
size_t TOPK = 20;
double hit = 0.;
double map5 = 0;
double map10 = 0;
TOPK = std::min(TOPK, list.size());
for (size_t idx = 0; idx < TOPK; ++idx) {
if (set.find(list[idx]) != set.end()) {
hit += 1.;
if (idx < 5) {
map5 += hit / (idx + 1);
}
if (idx < 10) {
map10 += hit / (idx + 1);
}
}
if (idx == 0) {
rets[0] = hit / 1.;
rets[3] = hit / set.size();
} else if (idx == 4) {
rets[1] = hit / 5.;
rets[4] = hit / set.size();
} else if (idx == 9) {
rets[2] = hit / 10.;
rets[5] = hit / set.size();
}// else if (idx == 19) {
// rets[3] = hit / 20.;
// rets[7] = hit / set.size();
// }
}
rets[6] = map5 / static_cast<double>(std::min(size_t(5), set.size()));
rets[7] = map10 / static_cast<double>(std::min(size_t(10), set.size()));
return std::move(rets);
}
std::string evaluate(const Model& model,
const Data& validation_data,
const Data& train_data = Data()) const {
CHECK_GT(validation_data.size(), 0);
auto validation_user_itemset = validation_data.get_feature_to_set_hashtable(0, 1);
std::unordered_map<size_t, std::unordered_set<size_t>> train_user_itemset;
if (train_data.size() != 0) {
train_user_itemset = train_data.get_feature_to_set_hashtable(0, 1);
}
size_t num_users = train_data.feature_group_total_dimension(0);
CHECK_EQ(num_users, train_user_itemset.size());
std::vector<std::vector<double>> user_rets(num_users);
parallel_for(0, num_users, [&](size_t uid) {
user_rets[uid] = std::vector<double>(8, 0.);
});
dynamic_parallel_for(0, num_users, [&](size_t uid) {
//for (size_t uid = 0; uid < num_users; ++uid) {
auto iter = validation_user_itemset.find(uid);
if (iter == validation_user_itemset.end()) return;
auto train_it = train_user_itemset.find(iter->first);
CHECK(train_it != train_user_itemset.end());
std::unordered_set<size_t>& validation_set = iter->second;
// Models are required to have this function
auto rec_list = model.recommend(iter->first, 10, train_it->second);
for (auto& rec_iid : rec_list) {
CHECK_LT(rec_iid, train_data.feature_group_total_dimension(1));
}
for (auto& iid : validation_set){
CHECK_LT(iid, train_data.feature_group_total_dimension(1));
}
auto eval_rets = evaluate_rec_list(rec_list, validation_set);
//std::transform(rets.begin(), rets.end(), eval_rets.begin(), rets.begin(),
// std::plus<double>());
user_rets[uid].assign(eval_rets.begin(), eval_rets.end());
});
//}
double num_users_for_test = static_cast<double>(validation_user_itemset.size());
std::vector<double> rets(8, 0.);
parallel_for(0, 8, [&](size_t colid) {
for (size_t uid = 0; uid < num_users; ++uid) {
rets[colid] += user_rets[uid][colid] / num_users_for_test;
}
});
std::stringstream ss;
ss << std::setw(8) << std::setprecision(5) << rets[0] << "|"
<< std::setw(8) << std::setprecision(5) << rets[1] << "|"
<< std::setw(8) << std::setprecision(5) << rets[2] << "|"
<< std::setw(8) << std::setprecision(5) << rets[3] << "|"
<< std::setw(8) << std::setprecision(5) << rets[4] << "|"
<< std::setw(8) << std::setprecision(5) << rets[5] << "|"
<< std::setw(8) << std::setprecision(5) << rets[6] << "|"
<< std::setw(8) << std::setprecision(5) << rets[7];// << "|"
//<< std::setw(8) << std::setprecision(5) << rets[8] << "|"
//<< std::setw(8) << std::setprecision(5) << rets[9];
return ss.str();
}
