/**
* Compute the covariance matrix for the row vectors.
* @param $matrix Could be RealMatrix or SparseMatrix.
* @return Matrix a new m by m covariance matrix.
* don't have to return by ref, because the engine will take care of it.
* Note that no matter what's the input matrix, the returned matrix is always a sparse matrix.
*/
static function correlation($matrix)
{
$vectors = $matrix->row_vectors();
$m = $matrix->row;
// dimension of the correlation matrix
$cor_matrix = Matrix::create('SparseMatrix', $m, $m);
for ($v1 = 0; $v1 < $m; $v1++) {
for ($v2 = $v1; $v2 < $m; $v2++) {
if (isset($vectors[$v1]) && isset($vectors[$v2])) {
// note, some value (such as std) is cached, so it won't be too much performance problem.
$cor = $vectors[$v1]->correlation($vectors[$v2]);
if (!is_nan($cor)) {
$cor_matrix->set($v1, $v2, $cor);
$cor_matrix->set($v2, $v1, $cor);
}
}
}
}
return $cor_matrix;
}
protected function computePredictionMemory()
{
// we do the computation based on $this->directMatrix loaded in memory, not on database
$this->mouseVectors = $this->directMatrix->row_vectors();
$aux_matrix = array();
// this is to store the normalized data (rating minus mean)
$m = $this->getMouseNum();
$n = $this->getCheeseNum();
$nan = $this->missing == 'none' ? TRUE : FALSE;
$data = array();
// calculate the difference matrix
foreach ($this->mouseVectors as $mouse_index => $mouse_vec) {
$mean = $mouse_vec->mean(TRUE);
for ($cheese_index = 0; $cheese_index < $n; $cheese_index++) {
if (!is_nan($mouse_vec->get($cheese_index))) {
$aux_matrix[$mouse_index][$cheese_index] = $mouse_vec->get($cheese_index) - $mean;
}
}
}
$values = $this->similarityMatrix->raw_values();
// not needed 'cause data will be saved directly to db.
$this->predictionMatrix = Matrix::create('SparseMatrix', $m, $n);
// calculate prediction for each mouse-cheese pair, and (optionally) save
foreach ($this->mouseMap as $mouse_id => $mouse_index) {
// (note: to improve performance w/ knn, move the for($j) loop here.)
// implement knn
if ($this->knn > 0) {
$sim_scores = $values[$mouse_index];
// make another copy
if (empty($sim_scores)) {
continue;
}
// if there's no knn, just skip.
arsort($sim_scores);
$sim_scores = array_slice($sim_scores, 0, $this->knn);
$neighbor = array_keys($sim_scores);
}
foreach ($this->cheeseMap as $cheese_id => $cheese_index) {
if ($this->duplicate == 'remove' && $this->recordExists($mouse_id, $cheese_id, $nan)) {
continue;
}
$numerator = 0;
$denomenator = 0;
for ($j = 0; $j < $m; $j++) {
if (isset($neighbor) && !in_array($j, $neighbor)) {
continue;
}
// if not k-nearest-neighbor, skip
if (!array_key_exists($cheese_index, $aux_matrix[$j])) {
continue;
}
// if no rating, skip.
if ($j == $mouse_index) {
continue;
}
// skip my own rating
$norm_weight = $aux_matrix[$j][$cheese_index];
$sim = $this->similarityMatrix->get($j, $mouse_index);
if (is_nan($sim)) {
continue;
}
$numerator += $norm_weight * $sim;
$denomenator += abs($sim);
}
if ($denomenator != 0) {
$prediction = $this->mouseVectors[$mouse_index]->mean(TRUE, $nan) + $numerator / $denomenator;
// note: we use the same lowerbound setting for prediction generation.
if ($prediction > $this->lowerbound) {
$data[] = "({$this->appId}, {$mouse_id}, {$cheese_id}, {$prediction}, {$this->created})";
}
}
}
}
$this->batchInsert($this->savePredictionSql(), $data);
$this->purgeOutdatedRecords('prediction');
$this->cleanupMemory();
}
protected function computePrediction()
{
// we do the computation based on $this->preferenceMatrix loaded in memory
$this->userVectors = $this->preferenceMatrix->row_vectors();
// regardless of whether preferenceMatrix is a sparse matrix or not, predictionMatrix is always a sparseMatrix.
$this->predictionMatrix = Matrix::create('SparseMatrix', $this->userNum, $this->itemNum);
// calculate prediction for each user-item pair
foreach ($this->userMap as $user_real_id => $user_matrix_index) {
foreach ($this->itemMap as $item_real_id => $item_matrix_index) {
// skip predictions on already existed preference ratings.
if (!$this->isBooleanRecommender && !is_nan($this->preferenceMatrix->get($user_matrix_index, $item_matrix_index)) || $this->isBooleanRecommender && $this->preferenceMatrix->get($user_matrix_index, $item_matrix_index) != 0) {
continue;
}
// $user_matrix_index is the current user's matrix index to computing. $j is the "similar users"
$numerator = 0;
$denominator = 0;
for ($j = 0; $j < $this->userNum; $j++) {
if ($j == $user_matrix_index) {
continue;
}
// skip myself.
if (is_nan($this->userVectors[$j]->get($item_matrix_index))) {
continue;
}
// if no rating from j, skip.
$similarity_value = $this->similarityMatrix->get($j, $user_matrix_index);
if (is_nan($similarity_value)) {
continue;
}
// skip if there is no similarity between $user_matrix_index and $j.
$mean_j = $this->isBooleanRecommender ? $this->userVectors[$j]->mean(TRUE) : $this->userVectors[$j]->intersect_mean($this->userVectors[$user_matrix_index]);
$normalized_j_score = $this->preferenceMatrix->get($j, $item_matrix_index) - $mean_j;
$numerator += $normalized_j_score * $similarity_value;
$denominator += abs($similarity_value);
}
if ($denominator != 0) {
$prediction = $this->userVectors[$user_matrix_index]->mean(TRUE) + $numerator / $denominator;
$this->predictionMatrix->set($user_matrix_index, $item_matrix_index, $prediction);
}
}
}
}
