def _update_time_features(self):
for tid in xrange(self.rateDao.num_times):
rated = self.trainData[self.trainData[self.columns[3]] == tid]
if not rated.empty:
rated_uids = map(lambda entry: entry[1][0], rated.iterrows())
rated_iids = map(lambda entry: entry[1][1], rated.iterrows())
X = self.P[rated_uids] * self.Q[rated_iids]
if tid == 0:
mean = (self.T[tid + 1] + self.mu_time) / 2
sigma = np.linalg.inv(2 * self.lambda_time +
self.alpha * np.dot(X.T, X))
elif tid < self.rateDao.num_times - 1:
rating = np.array(
map(lambda entry: entry[1][2],
rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(2 * self.lambda_time +
self.alpha * np.dot(X.T, X))
mu_temp = np.dot(
self.lambda_time, self.T[tid - 1] +
self.T[tid + 1]) + self.alpha * np.dot(rating, X)
mean = np.dot(sigma, mu_temp)
else:
rating = np.array(
map(lambda entry: entry[1][2],
rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(self.lambda_time +
self.alpha * np.dot(X.T, X))
mu_temp = np.dot(
self.lambda_time,
self.T[tid - 1]) + self.alpha * np.dot(rating, X)
mean = np.dot(sigma, mu_temp)
self.T[tid] = mv_normalrand(mean, sigma, self.factors)
def _update_item_features(self):
for iid in xrange(self.rateDao.num_items):
vec = self.V[:, iid] > 0
features = self.P[vec]
rating = self.V[vec, iid] - self.global_mean
sigma = np.linalg.inv(self.lambda_item + self.alpha * np.dot(features.T, features))
mu_temp = self.alpha * np.dot(features.T, rating) + np.dot(self.lambda_item, self.mu_item)
mean = np.dot(sigma, mu_temp)
self.Q[iid] = mv_normalrand(mean, sigma, self.factors)
def _update_user_features(self):
for uid in xrange(self.rateDao.num_users):
vec = self.V[uid, :] > 0
features = self.Q[vec]
rating = self.V[uid, vec] - self.global_mean
sigma = np.linalg.inv(self.lambda_user + self.alpha * np.dot(features.T, features))
mu_temp = self.alpha * np.dot(features.T, rating) + np.dot(self.lambda_user, self.mu_user)
mean = np.dot(sigma, mu_temp)
self.P[uid] = mv_normalrand(mean, sigma, self.factors)
def _update_item_features(self):
for iid in xrange(self.rateDao.num_items):
vec = self.V[:, iid] > 0
features = self.P[vec]
rating = self.V[vec, iid] - self.global_mean
sigma = np.linalg.inv(self.lambda_item +
self.alpha * np.dot(features.T, features))
mu_temp = self.alpha * np.dot(features.T, rating) + np.dot(
self.lambda_item, self.mu_item)
mean = np.dot(sigma, mu_temp)
self.Q[iid] = mv_normalrand(mean, sigma, self.factors)
def _update_user_features(self):
for uid in xrange(self.rateDao.num_users):
vec = self.V[uid, :] > 0
features = self.Q[vec]
rating = self.V[uid, vec] - self.global_mean
sigma = np.linalg.inv(self.lambda_user +
self.alpha * np.dot(features.T, features))
mu_temp = self.alpha * np.dot(features.T, rating) + np.dot(
self.lambda_user, self.mu_user)
mean = np.dot(sigma, mu_temp)
self.P[uid] = mv_normalrand(mean, sigma, self.factors)
def _update_item_params(self):
N = self.rateDao.num_items
X_bar = np.mean(self.Q, 0)
S_bar = np.cov(self.Q.T)
norm_X_bar = self.mu0_i - X_bar
WI_post = self.WI_item + N * S_bar + np.outer(norm_X_bar) * (N * self.beta_item) / (self.beta_item + N)
WI_post = (WI_post + WI_post.T) / 2.
df_post = self.df_item + N
self.lambda_item = wishart.rvs(df_post, WI_post)
mu_temp = (self.beta_item * self.mu0_i + N * X_bar) / (self.beta_item + N)
sigma_temp = np.linalg.inv(np.dot(self.beta_item + N, self.lambda_item))
self.mu_item = mv_normalrand(mu_temp, sigma_temp, self.factors)
def _update_item_features(self):
for iid in xrange(self.rateDao.num_items):
rated = self.trainData[self.trainData[self.columns[1]] == iid]
if not rated.empty:
rated_uids = map(lambda entry: entry[1][0], rated.iterrows())
rated_tids = map(lambda entry: entry[1][3], rated.iterrows())
P = self.P[rated_uids] * self.T[rated_tids]
rating = np.array(map(lambda entry: entry[1][2], rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(self.lambda_item + self.alpha * np.dot(P.T, P))
mu_temp = self.alpha * np.dot(rating, P) + np.dot(self.lambda_item, self.mu_item)
mean = np.dot(sigma, mu_temp)
self.Q[iid] = mv_normalrand(mean, sigma, self.factors)
def _update_time_params(self):
N = self.rateDao.num_times
diff_temp = np.diff(self.T, axis=0)
diff_t0 = self.T[0] - self.mu0_t
WI_post = self.WI_time + np.dot(diff_temp.T, diff_temp) + self.beta_time / (1 + self.beta_time) * np.outer(
diff_t0, diff_t0)
WI_post = (WI_post + WI_post.T) / 2.
df_post = self.df_item + N
self.lambda_time = wishart.rvs(df_post, WI_post)
mu_temp = (self.beta_time * self.mu0_t + self.T[0]) / (self.beta_item + 1)
sigma_temp = np.linalg.inv(np.dot(self.beta_item + 1, self.lambda_time))
self.mu_time = mv_normalrand(mu_temp, sigma_temp, self.factors)
def _update_user_features(self):
for uid in xrange(self.rateDao.num_users):
rated = self.trainData[self.trainData[self.columns[0]] == uid]
if not rated.empty:
rated_iids = map(lambda entry: entry[1][1], rated.iterrows())
rated_tids = map(lambda entry: entry[1][3], rated.iterrows())
# 逐元素相乘，不是点积
Q = self.Q[rated_iids] * self.T[rated_tids]
rating = np.array(map(lambda entry: entry[1][2], rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(self.lambda_user + self.alpha * np.dot(Q.T, Q))
mu_temp = self.alpha * np.dot(rating, Q) + np.dot(self.lambda_user, self.mu_user)
mean = np.dot(sigma, mu_temp)
self.P[uid] = mv_normalrand(mean, sigma, self.factors)
def _update_user_params(self):
N = self.rateDao.num_users
X_bar = np.mean(self.P, 0)
S_bar = np.cov(self.P.T)
norm_X_bar = self.mu0_u - X_bar
WI_post = self.WI_user + N * S_bar + np.outer(norm_X_bar) * (N * self.beta_user) / (self.beta_user + N)
# ensure the matrix's symmetry
WI_post = (WI_post + WI_post.T) / 2.
df_post = self.df_user + N
self.lambda_user = wishart.rvs(df_post, WI_post)
# 以下可参考http://blog.pluskid.org/?p=430
mu_temp = (self.beta_user * self.mu0_u + N * X_bar) / (self.beta_user + N)
sigma_temp = np.linalg.inv(np.dot(self.beta_user + N, self.lambda_user))
self.mu_user = mv_normalrand(mu_temp, sigma_temp, self.factors)
def _update_time_params(self):
N = self.rateDao.num_times
diff_temp = np.diff(self.T, axis=0)
diff_t0 = self.T[0] - self.mu0_t
WI_post = self.WI_time + np.dot(
diff_temp.T, diff_temp) + self.beta_time / (
1 + self.beta_time) * np.outer(diff_t0, diff_t0)
WI_post = (WI_post + WI_post.T) / 2.
df_post = self.df_item + N
self.lambda_time = wishart.rvs(df_post, WI_post)
mu_temp = (self.beta_time * self.mu0_t + self.T[0]) / (self.beta_item +
1)
sigma_temp = np.linalg.inv(np.dot(self.beta_item + 1,
self.lambda_time))
self.mu_time = mv_normalrand(mu_temp, sigma_temp, self.factors)
def _update_item_params(self):
N = self.rateDao.num_items
X_bar = np.mean(self.Q, 0)
S_bar = np.cov(self.Q.T)
norm_X_bar = self.mu0_i - X_bar
WI_post = self.WI_item + N * S_bar + np.outer(norm_X_bar) * (
N * self.beta_item) / (self.beta_item + N)
WI_post = (WI_post + WI_post.T) / 2.
df_post = self.df_item + N
self.lambda_item = wishart.rvs(df_post, WI_post)
mu_temp = (self.beta_item * self.mu0_i + N * X_bar) / (self.beta_item +
N)
sigma_temp = np.linalg.inv(np.dot(self.beta_item + N,
self.lambda_item))
self.mu_item = mv_normalrand(mu_temp, sigma_temp, self.factors)
def _update_item_features(self):
for iid in xrange(self.rateDao.num_items):
rated = self.trainData[self.trainData[self.columns[1]] == iid]
if not rated.empty:
rated_uids = map(lambda entry: entry[1][0], rated.iterrows())
rated_tids = map(lambda entry: entry[1][3], rated.iterrows())
P = self.P[rated_uids] * self.T[rated_tids]
rating = np.array(
map(lambda entry: entry[1][2],
rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(self.lambda_item +
self.alpha * np.dot(P.T, P))
mu_temp = self.alpha * np.dot(rating, P) + np.dot(
self.lambda_item, self.mu_item)
mean = np.dot(sigma, mu_temp)
self.Q[iid] = mv_normalrand(mean, sigma, self.factors)
def _update_user_features(self):
for uid in xrange(self.rateDao.num_users):
rated = self.trainData[self.trainData[self.columns[0]] == uid]
if not rated.empty:
rated_iids = map(lambda entry: entry[1][1], rated.iterrows())
rated_tids = map(lambda entry: entry[1][3], rated.iterrows())
# 逐元素相乘，不是点积
Q = self.Q[rated_iids] * self.T[rated_tids]
rating = np.array(
map(lambda entry: entry[1][2],
rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(self.lambda_user +
self.alpha * np.dot(Q.T, Q))
mu_temp = self.alpha * np.dot(rating, Q) + np.dot(
self.lambda_user, self.mu_user)
mean = np.dot(sigma, mu_temp)
self.P[uid] = mv_normalrand(mean, sigma, self.factors)
def _update_user_params(self):
N = self.rateDao.num_users
X_bar = np.mean(self.P, 0)
S_bar = np.cov(self.P.T)
norm_X_bar = self.mu0_u - X_bar
WI_post = self.WI_user + N * S_bar + np.outer(norm_X_bar) * (
N * self.beta_user) / (self.beta_user + N)
# ensure the matrix's symmetry
WI_post = (WI_post + WI_post.T) / 2.
df_post = self.df_user + N
self.lambda_user = wishart.rvs(df_post, WI_post)
# 以下可参考http://blog.pluskid.org/?p=430
mu_temp = (self.beta_user * self.mu0_u + N * X_bar) / (self.beta_user +
N)
sigma_temp = np.linalg.inv(np.dot(self.beta_user + N,
self.lambda_user))
self.mu_user = mv_normalrand(mu_temp, sigma_temp, self.factors)
def _update_time_features(self):
for tid in xrange(self.rateDao.num_times):
rated = self.trainData[self.trainData[self.columns[3]] == tid]
if not rated.empty:
rated_uids = map(lambda entry: entry[1][0], rated.iterrows())
rated_iids = map(lambda entry: entry[1][1], rated.iterrows())
X = self.P[rated_uids] * self.Q[rated_iids]
if tid == 0:
mean = (self.T[tid + 1] + self.mu_time) / 2
sigma = np.linalg.inv(2 * self.lambda_time + self.alpha * np.dot(X.T, X))
elif tid < self.rateDao.num_times - 1:
rating = np.array(map(lambda entry: entry[1][2], rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(2 * self.lambda_time + self.alpha * np.dot(X.T, X))
mu_temp = np.dot(self.lambda_time, self.T[tid - 1] + self.T[tid + 1]) + self.alpha * np.dot(rating,
X)
mean = np.dot(sigma, mu_temp)
else:
rating = np.array(map(lambda entry: entry[1][2], rated.iterrows())) - self.global_mean
sigma = np.linalg.inv(self.lambda_time + self.alpha * np.dot(X.T, X))
mu_temp = np.dot(self.lambda_time, self.T[tid - 1]) + self.alpha * np.dot(rating, X)
mean = np.dot(sigma, mu_temp)
self.T[tid] = mv_normalrand(mean, sigma, self.factors)