I want to lower the RMSE value further, can you modify the code using more effective collabritve filtering methods?

#include #include #include #include #include #include #include #include #include

// A struct to represent a rating given by a user to an item struct Rating { int user_id; int item_id; float rating; };

// A struct to represent a predicted rating for an item struct PredictedRating { int id; int user_id; int item_id; float rating; };

// Reads the ratings from a .csv file and returns them as a vector std::vector read_ratings(const std::string& filename) { std::vector ratings;

std::ifstream file(filename); if (file.is_open()) { std::string line; // Skip the first line (header) std::getline(file, line); while (std::getline(file, line)) { Rating rating; std::sscanf(line.c_str(), "%d,%d,%f", &rating.user_id, &rating.item_id, &rating.rating); ratings.push_back(rating); } file.close(); }

return ratings; }

// Reads the test cases from a .csv file and returns them as a vector std::vector read_test_cases(const std::string& filename) { std::vector test_cases;

std::ifstream file(filename); if (file.is_open()) { std::string line; // Skip the first line (header) std::getline(file, line); while (std::getline(file, line)) { PredictedRating test_case; std::sscanf(line.c_str(), "%d,%d,%d", &test_case.id, &test_case.user_id, &test_case.item_id); test_cases.push_back(test_case); } file.close(); }

return test_cases; }

// Calculates the root mean squared error between the predicted ratings and the actual ratings float calculate_rmse(const std::vector& predicted_ratings, const std::vector& actual_ratings) { float sum_squared_error = 0.0f; for (const auto& predicted_rating : predicted_ratings) { auto actual_rating_iter = std::find_if(actual_ratings.begin(), actual_ratings.end(), [&](const Rating& r) { return r.user_id == predicted_rating.user_id && r.item_id == predicted_rating.item_id; }); if (actual_rating_iter != actual_ratings.end()) { sum_squared_error += std::pow(predicted_rating.rating - actual_rating_iter->rating, 2); } } return std::sqrt(sum_squared_error / predicted_ratings.size()); }

float predict_rating_mean_item(int user_id, int item_id, const std::unordered_map>& item_ratings) { // If the item has not been rated by any users, return the mean rating of all items if (item_ratings.count(item_id) == 0) { float sum_ratings = 0.0f; int num_ratings = 0; for (const auto& [_, ratings] : item_ratings) { for (const auto& rating : ratings) { sum_ratings += rating.rating; num_ratings++; } } return sum_ratings / num_ratings; } else { // If the item has been rated by at least one user, return the mean rating of the item float sum_ratings = 0.0f; int num_ratings = 0; for (const auto& rating : item_ratings.at(item_id)) { sum_ratings += rating.rating; num_ratings++; } return sum_ratings / num_ratings; } }

int main() { // Read in the training and test sets std::vector training_set = read_ratings("train.csv"); std::vector test_set = read_test_cases("test.csv");

// Initialize a map to store the ratings received by each item std::unordered_map> item_ratings; for (const auto& rating : training_set) { item_ratings[rating.item_id].push_back(rating); }

std::fstream fout;

// opens an existing csv file or creates a new file. fout.open("report.csv", std::ios::out | std::ios::app);

// Predict the ratings for the test set using the mean rating of the item for (auto& predicted_rating : test_set) { predicted_rating.rating = predict_rating_mean_item(predicted_rating.user_id, predicted_rating.item_id, item_ratings); fout << std::to_string(predicted_rating.id) << "," << std::to_string(predicted_rating.rating) << " "; }

// Calculate the RMSE between the predicted ratings and the actual ratings float rmse = calculate_rmse(test_set, training_set); std::cout << "RMSE: " << rmse << std::endl;

return 0; }