def test_save_and_load_model(self):
model = TensorRec(n_components=10)
model.fit(self.interactions, self.user_features, self.item_features, epochs=10)
predictions = model.predict(user_features=self.user_features, item_features=self.item_features)
ranks = model.predict_rank(user_features=self.user_features, item_features=self.item_features)
model.save_model(directory_path=self.test_dir)
# Check that, after saving, the same predictions come back
predictions_after_save = model.predict(user_features=self.user_features, item_features=self.item_features)
ranks_after_save = model.predict_rank(user_features=self.user_features, item_features=self.item_features)
self.assertTrue((predictions == predictions_after_save).all())
self.assertTrue((ranks == ranks_after_save).all())
# Blow away the session
set_session(None)
tf.reset_default_graph()
# Reload the model, predict, and check for equal predictions
new_model = TensorRec.load_model(directory_path=self.test_dir)
new_predictions = new_model.predict(user_features=self.user_features, item_features=self.item_features)
new_ranks = new_model.predict_rank(user_features=self.user_features, item_features=self.item_features)
self.assertTrue((predictions == new_predictions).all())
self.assertTrue((ranks == new_ranks).all())
def test_fit_from_tfrecords(self):
set_session(None)
model = TensorRec(n_components=10)
model.fit(self.interactions_path,
self.user_features_path,
self.item_features_path,
epochs=10)
def test_save_and_load_model(self):
model = TensorRec(n_components=10)
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=10)
predictions = model.predict(user_features=self.user_features,
item_features=self.item_features)
ranks = model.predict_rank(user_features=self.user_features,
item_features=self.item_features)
model.save_model(directory_path=self.test_dir)
# Check that, after saving, the same predictions come back
predictions_after_save = model.predict(
user_features=self.user_features, item_features=self.item_features)
ranks_after_save = model.predict_rank(user_features=self.user_features,
item_features=self.item_features)
self.assertTrue((predictions == predictions_after_save).all())
self.assertTrue((ranks == ranks_after_save).all())
# Blow away the session
set_session(None)
tf.reset_default_graph()
# Reload the model, predict, and check for equal predictions
new_model = TensorRec.load_model(directory_path=self.test_dir)
new_predictions = new_model.predict(user_features=self.user_features,
item_features=self.item_features)
new_ranks = new_model.predict_rank(user_features=self.user_features,
item_features=self.item_features)
self.assertTrue((predictions == new_predictions).all())
self.assertTrue((ranks == new_ranks).all())
def test_wmrb_loss(self):
model = TensorRec(loss_graph=WMRBLossGraph())
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=5,
n_sampled_items=10)
def setUpClass(cls):
cls.interactions, cls.user_features, cls.item_features = generate_dummy_data_with_indicator(
num_users=10, num_items=12, interaction_density=.5)
model = TensorRec(n_components=10)
model.fit(cls.interactions, cls.user_features, cls.item_features, epochs=10)
cls.model = model
cls.ranks = model.predict_rank(user_features=cls.user_features, item_features=cls.item_features)
def test_balanced_wmrb_loss_biased(self):
model = TensorRec(loss_graph=BalancedWMRBLossGraph(), biased=True)
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=5,
n_sampled_items=10)
def test_basic_usage(self):
# Build the model with default parameters
model = TensorRec()
# Generate some dummy data
interactions, user_features, item_features = generate_dummy_data(
num_users=100, num_items=150, interaction_density=.05)
# Fit the model
model.fit(interactions,
user_features,
item_features,
epochs=5,
verbose=True)
# Predict scores for user 75 on items 100, 101, and 102
predictions = model.predict(user_ids=[75, 75, 75],
item_ids=[100, 101, 102],
user_features=user_features,
item_features=item_features)
# Calculate and print the recall at 10
r_at_k = recall_at_k(model,
interactions,
k=10,
user_features=user_features,
item_features=item_features)
print(np.mean(r_at_k))
self.assertIsNotNone(predictions)
def test_fit(self):
interactions, user_features, item_features = generate_dummy_data(
num_users=10, num_items=10, interaction_density=.5)
model = TensorRec(n_components=10)
model.fit(interactions, user_features, item_features, epochs=10)
# Ensure that the nodes have been built
self.assertIsNotNone(model.tf_prediction_dense)
def test_fit_predict_unbiased(self): model = TensorRec(n_components=10, biased=False) model.fit(self.interactions, self.user_features, self.item_features, epochs=10) predictions = model.predict(user_features=self.user_features, item_features=self.item_features) self.assertEqual(predictions.shape, (self.user_features.shape[0], self.item_features.shape[0]))
def test_fit_interactions_as_dataset(self):
int_as_dataset = create_tensorrec_dataset_from_sparse_matrix(
self.interactions)
model = TensorRec(n_components=10)
model.fit(int_as_dataset,
self.user_features,
self.item_features,
epochs=10)
def test_fit(self):
model = TensorRec(n_components=10)
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=10)
# Ensure that the nodes have been built
self.assertIsNotNone(model.tf_prediction)
def setUpClass(cls):
cls.interactions, cls.user_features, cls.item_features = generate_dummy_data(
num_users=10, num_items=12, interaction_density=.5)
model = TensorRec(n_components=10)
model.fit(cls.interactions,
cls.user_features,
cls.item_features,
epochs=10)
cls.model = model
def test_predict_user_repr_biased_fails(self):
model = TensorRec(n_components=10)
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=10)
with self.assertRaises(NotImplementedError):
model.predict_user_representation(self.user_features)
def test_predict_item_repr(self):
model = TensorRec(n_components=10, biased=False)
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=10)
item_repr = model.predict_item_representation(self.item_features)
self.assertEqual(item_repr.shape, (self.item_features.shape[0], 10))
def test_fit_from_datasets(self):
uf_as_dataset = create_tensorrec_dataset_from_sparse_matrix(
self.user_features, False)
if_as_dataset = create_tensorrec_dataset_from_sparse_matrix(
self.item_features, True)
int_as_dataset = create_tensorrec_dataset_from_sparse_matrix(
self.interactions, False)
model = TensorRec(n_components=10)
model.fit(int_as_dataset, uf_as_dataset, if_as_dataset, epochs=10)
def metric_test(self):
""" uses tensorrec eval as benchmark for rating performance of various reco algorithms """
k = 10
latent_factor = 10
n_users = 10
n_items = 12
interactions, user_features, item_features = util.generate_dummy_data_with_indicator(
num_users=n_users, num_items=n_items, interaction_density=.5)
print("interactiosn shape={}".format(np.shape(interactions)))
print("user features shape={}".format(np.shape(
user_features.toarray())))
print("item features shape={}".format(np.shape(
item_features.toarray())))
model = TensorRec(n_components=latent_factor)
model.fit(interactions, user_features, item_features, epochs=19)
ranks = model.predict_rank(user_features=user_features,
item_features=item_features)
print("Ranks shape={}".format(np.shape(ranks)))
self.assertTrue(np.shape(interactions) == np.shape(ranks))
tr_recall_result = eval.recall_at_k(predicted_ranks=ranks,
test_interactions=interactions,
k=k,
preserve_rows=False)
# print (tr_recall_result.mean())
tr_precision_result = eval.precision_at_k(
predicted_ranks=ranks,
test_interactions=interactions,
k=k,
preserve_rows=False)
# print(tr_precision_result.mean())
# we need csr for interactions data
interactions_ = interactions.tocsr()
recall_result = metrics.recall_at_k(ranks,
interactions_,
k=k,
preserve_rows=False)
# print(recall_result.mean())
precision_result = metrics.precision_at_k(ranks,
interactions_,
k=k,
preserve_rows=False)
# print (precision_result.mean())
self.assertTrue(tr_recall_result.mean() == recall_result.mean())
self.assertTrue(tr_precision_result.mean() == precision_result.mean())
def test_fit_fail_batching_dataset(self):
model = TensorRec(n_components=10)
interactions_as_dataset = create_tensorrec_dataset_from_sparse_matrix(
self.interactions)
with self.assertRaises(BatchNonSparseInputException):
model.fit(interactions_as_dataset,
self.user_features,
self.item_features,
epochs=10,
user_batch_size=2)
def setUpClass(cls):
cls.interactions, cls.user_features, cls.item_features = generate_dummy_data_with_indicator(
num_users=10, num_items=12, interaction_density=.5)
model = TensorRec(n_components=10)
model.fit(cls.interactions,
cls.user_features,
cls.item_features,
epochs=10)
cls.model = model
cls.ranks = model.predict_rank(user_features=cls.user_features,
item_features=cls.item_features)
def test_predict(self):
interactions, user_features, item_features = generate_dummy_data(
num_users=10, num_items=20, interaction_density=.5)
model = TensorRec(n_components=10)
model.fit(interactions, user_features, item_features, epochs=10)
predictions = model.predict(user_features=user_features,
item_features=item_features)
self.assertEqual(predictions.shape,
(user_features.shape[0], item_features.shape[0]))
def test_wmrb_loss(self):
model = TensorRec(loss_graph=WMRBLossGraph(),
stratified_sample=True,
logdir='/Users/jasonchen/tmp/test',
log_interval=100)
model.fit(self.interactions.tocsr(),
self.user_features.tocsr(),
self.item_features.tocsr()[:self.n_test_item],
epochs=10,
verbose=True,
train_threads=5,
use_reg=True)
def test_predict(self):
interactions, user_features, item_features = generate_dummy_data(
num_users=10, num_items=10, interaction_density=.5)
model = TensorRec(n_components=10)
model.fit(interactions, user_features, item_features, epochs=10)
predictions = model.predict(user_ids=[1, 2, 3],
item_ids=[4, 5, 6],
user_features=user_features,
item_features=item_features)
self.assertEqual(len(predictions), 3)
def test_movie_lens_fit_wmrb(self):
"""
This test checks whether the movielens getter works and that the resulting data is viable for fitting/testing a
TensorRec model.
"""
train_interactions, test_interactions, user_features, item_features = self.movielens_100k
model = TensorRec(loss_graph=wmrb_loss)
model.fit(interactions=train_interactions,
user_features=user_features,
item_features=item_features)
predictions = model.predict(user_features=user_features,
item_features=item_features)
self.assertIsNotNone(predictions)
def test_save_and_load_model_same_session(self):
model = TensorRec(n_components=10)
model.fit(self.interactions, self.user_features, self.item_features, epochs=10)
predictions = model.predict(user_features=self.user_features, item_features=self.item_features)
ranks = model.predict_rank(user_features=self.user_features, item_features=self.item_features)
model.save_model(directory_path=self.test_dir)
# Reload the model, predict, and check for equal predictions
new_model = TensorRec.load_model(directory_path=self.test_dir)
new_predictions = new_model.predict(user_features=self.user_features, item_features=self.item_features)
new_ranks = new_model.predict_rank(user_features=self.user_features, item_features=self.item_features)
self.assertTrue((predictions == new_predictions).all())
self.assertTrue((ranks == new_ranks).all())
def test_save_and_load_model_same_session(self): model = TensorRec(n_components=10) model.fit(self.interactions, self.user_features, self.item_features, epochs=10) predictions = model.predict(user_features=self.user_features, item_features=self.item_features) ranks = model.predict_rank(user_features=self.user_features, item_features=self.item_features) model.save_model(directory_path=self.test_dir) # Reload the model, predict, and check for equal predictions new_model = TensorRec.load_model(directory_path=self.test_dir) new_predictions = new_model.predict(user_features=self.user_features, item_features=self.item_features) new_ranks = new_model.predict_rank(user_features=self.user_features, item_features=self.item_features) self.assertEqual(predictions.all(), new_predictions.all()) self.assertEqual(ranks.all(), new_ranks.all())
def test_movie_lens_fit(self):
"""
This test checks whether the movielens getter works and that the resulting data is viable for fitting/testing a
TensorRec model.
"""
train_interactions, test_interactions, user_features, item_features, _ = self.movielens_100k
model = TensorRec()
model.fit(interactions=train_interactions,
user_features=user_features,
item_features=item_features,
epochs=5)
predictions = model.predict(user_features=user_features,
item_features=item_features)
self.assertIsNotNone(predictions)
def test_fit(self, name, user_repr, item_repr, n_user_features,
n_item_features, n_components):
interactions, user_features, item_features = generate_dummy_data(
num_users=15,
num_items=30,
interaction_density=.5,
num_user_features=n_user_features,
num_item_features=n_item_features,
n_features_per_user=20,
n_features_per_item=20,
pos_int_ratio=.5)
model = TensorRec(n_components=n_components,
user_repr_graph=user_repr(),
item_repr_graph=item_repr())
model.fit(interactions, user_features, item_features, epochs=10)
# Ensure that the nodes have been built
self.assertIsNotNone(model.tf_prediction)
def test_fit_fail_bad_input(self):
model = TensorRec(n_components=10)
with self.assertRaises(ValueError):
model.fit(np.array([1, 2, 3, 4]), self.user_features, self.item_features, epochs=10)
with self.assertRaises(ValueError):
model.fit(self.interactions, np.array([1, 2, 3, 4]), self.item_features, epochs=10)
with self.assertRaises(ValueError):
model.fit(self.interactions, self.user_features, np.array([1, 2, 3, 4]), epochs=10)
def test_fit_fail_on_bad_dims(self):
interactions, user_features, item_features = generate_dummy_data(
num_users=15,
num_items=30,
interaction_density=.5,
num_user_features=30,
num_item_features=20,
n_features_per_user=20,
n_features_per_item=20,
pos_int_ratio=.5)
with self.assertRaises(ValueError):
model = TensorRec(
n_components=25,
user_repr_graph=FeaturePassThroughRepresentationGraph(),
item_repr_graph=LinearRepresentationGraph())
model.fit(interactions, user_features, item_features, epochs=10)
with self.assertRaises(ValueError):
model = TensorRec(
n_components=25,
user_repr_graph=LinearRepresentationGraph(),
item_repr_graph=FeaturePassThroughRepresentationGraph())
model.fit(interactions, user_features, item_features, epochs=10)
def test_fit_fail_mismatched_batches(self):
model = TensorRec(n_components=10)
with self.assertRaises(ValueError):
model.fit(
self.interactions, [self.user_features, self.user_features],
[self.item_features, self.item_features, self.item_features],
epochs=10)
with self.assertRaises(ValueError):
model.fit(self.interactions,
[self.user_features, self.user_features],
[self.item_features, self.item_features],
epochs=10)
model.fit([self.interactions, self.interactions],
[self.user_features, self.user_features],
self.item_features,
epochs=10)
model.fit([self.interactions, self.interactions],
[self.user_features, self.user_features],
[self.item_features, self.item_features],
epochs=10)
def test_fit_fail_mismatched_batches(self):
model = TensorRec(n_components=10)
with self.assertRaises(ValueError):
model.fit(self.interactions,
[self.user_features, self.user_features],
[self.item_features, self.item_features, self.item_features],
epochs=10)
with self.assertRaises(ValueError):
model.fit(self.interactions,
[self.user_features, self.user_features],
[self.item_features, self.item_features],
epochs=10)
model.fit([self.interactions, self.interactions],
[self.user_features, self.user_features],
self.item_features,
epochs=10)
model.fit([self.interactions, self.interactions],
[self.user_features, self.user_features],
[self.item_features, self.item_features],
epochs=10)
def test_fit_from_datasets(self):
uf_as_dataset = create_tensorrec_dataset_from_sparse_matrix(self.user_features)
if_as_dataset = create_tensorrec_dataset_from_sparse_matrix(self.item_features)
int_as_dataset = create_tensorrec_dataset_from_sparse_matrix(self.interactions)
model = TensorRec(n_components=10)
model.fit(int_as_dataset, uf_as_dataset, if_as_dataset, epochs=10)
def test_fit_from_tfrecords(self):
set_session(None)
model = TensorRec(n_components=10)
model.fit(self.interactions_path, self.user_features_path, self.item_features_path, epochs=10)
def test_fit_verbose(self):
model = TensorRec(n_components=10)
model.fit(self.interactions, self.user_features, self.item_features, epochs=10, verbose=True)
# Ensure that the nodes have been built
self.assertIsNotNone(model.tf_prediction)
def test_fit_batched(self):
model = TensorRec(n_components=10)
model.fit(self.interactions, self.user_features, self.item_features, epochs=10, user_batch_size=2)
# Ensure that the nodes have been built
self.assertIsNotNone(model.tf_prediction)
def test_separation_loss(self):
model = TensorRec(loss_graph=separation_loss)
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=5)
def main():
# 데이터 로드
## 마스터 데이터(상호 작용)
masterdf = pd.read_csv('./data/Transactions.csv')
masterdf.columns = ['Transaction ID', 'Customer ID', 'Transaction Date', 'Prod Subcat Code',
'Prod Cat Code', 'Qty', 'Rate', 'Tax', 'Total Amt', 'Store Type'] # 데이터 정리 및 표준화를 위해 데이터 열 명칭 변경
masterdf['Store Type Code'] = pd.factorize(masterdf['Store Type'])[0] # 상점 코드 타입을 숫자형으로 변경하여 새 열에 저장
masterdf['Date'] = pd.DatetimeIndex(masterdf['Transaction Date'], dayfirst=True).date # 거래 날짜를 pandas의 datetime index로 표준화
masterdf['Net Sales'] = masterdf['Qty'] * masterdf['Rate'] # quantity와 based price에서 총 순 매출액(Net sales) 계산 (도시마다의 세금이 다를 수 있어 세금 제외)
masterdf['Material'] = masterdf['Prod Cat Code'].astype(str) + '-' + masterdf['Prod Subcat Code'].astype(str) + '-' + masterdf['Store Type'].astype(str) # category, subcategory, store type을 이용하여 고유한 material 표시기를 생성
masterdf[['Prod Cat Code','Prod Subcat Code', 'Store Type', 'Material']].drop_duplicates(subset='Material')
## 소비자 데이터(소비자 특성)
custdf = pd.read_csv('./data/Customer.csv')
custdf.columns = ['Customer ID', 'DOB', 'Gender', 'City Code']
## 아이탬 특징 데이터
skudf = pd.read_csv('./data/prod_cat_info.csv')
skudf.columns = ['Prod Cat Code', 'Prod Cat', 'Prod Sub Cat Code', 'Prod Subcat']
# 데이터 생성
## RECENCY (최신성)
recency_df = masterdf.groupby('Customer ID').Date.max().reset_index()
recency_df.columns = ['Customer ID','Last Purchase']
recency_df['Recency'] = recency_df['Last Purchase'].apply(lambda x: (now - x).days)
recency_df = recency_df[['Customer ID', 'Recency']]
## FREQUENCY (빈도)
frequency_df = masterdf.groupby('Customer ID')['Date'].count().reset_index()
frequency_df.columns = ['Customer ID','Frequency']
## MONETARY (금액)
monetary_df = masterdf.groupby('Customer ID')['Net Sales'].sum().reset_index()
monetary_df.columns = ['Customer ID','Monetary']
## VARIETY (종류)
variety_df = masterdf.groupby('Customer ID')['Material'].nunique().reset_index()
variety_df.columns = ['Customer ID','Variety']
## RFMV
rfmv = recency_df.copy()
rfmv = rfmv.merge(frequency_df, on='Customer ID')
rfmv = rfmv.merge(monetary_df, on='Customer ID')
rfmv = rfmv.merge(variety_df, on='Customer ID')
rfmv_quantiles = rfmv.iloc[:, 1:].quantile(q = [0.25, 0.5, 0.75]).to_dict() # R, F, M, V의 25%, 50%, 75%의 사분위수를 dictonary 형식으로 저장
rfmv2 = rfmv.copy()
rfmv2['R_q'] = rfmv2['Recency'].apply(RecencyScore, args=('Recency', rfmv_quantiles ))
rfmv2['F_q'] = rfmv2['Frequency'].apply(FMVScore, args=('Frequency', rfmv_quantiles ))
rfmv2['M_q'] = rfmv2['Monetary'].apply(FMVScore, args=('Monetary', rfmv_quantiles ))
rfmv2['V_q'] = rfmv2['Variety'].apply(FMVScore, args=('Variety', rfmv_quantiles ))
rfmv2 = rfmv2[['Customer ID', 'R_q', 'F_q', 'M_q', 'V_q',]]
## 각 구성 요소의 총 점수 합계
rfmv2['Total_Score'] = rfmv2['R_q'] + rfmv2['F_q'] + rfmv2['M_q'] + rfmv2['V_q']
rfmv2 = rfmv2[['Customer ID', 'Total_Score']]
# 중요(IMPORTANT) : 인덱스를 고객 번호로 설정
rfmv2.index = rfmv2['Customer ID']
rfmv2 = rfmv2.drop('Customer ID', 1)
# 최적의 군집 수를 찾기 위해 elbow 방식 (차후 이 과정을 조정할 필요가 있음)
wcss = []
for i in range(2,10):
kmeans = KMeans(n_clusters=i,
init='k-means++')
kmeans.fit(rfmv2)
wcss.append(kmeans.inertia_)
# 위 "elbow" 그래프의 최적의 수를 이용하여 KMean 군집 적용
kmeans = KMeans(n_clusters=4,
init='random',
random_state=None)
clusters = kmeans.fit_predict(rfmv2)
### 군집 결과를 원본 rfmv 데이터에 추가
rfmv['Clusters'] = clusters
# Recommendation Weight
active_cust = rfmv[rfmv.Recency < 365] # 최근 1년(365일)을 기준으로 하여 실고객에게 추천
cleaned_df = masterdf.merge(active_cust[['Customer ID','Clusters']], how='left', on='Customer ID') # 군집화된 고객 특징을 마스터 데이터에 결합
cleaned_df = cleaned_df[cleaned_df['Clusters'].notnull()] # 군집을 기준으로 null 값이 존재하는 행 삭제
cleaned_df = cleaned_df.merge(custdf[['Customer ID', 'City Code']], how='left', on='Customer ID') ## 소비자 데이터 추가
cleaned_df = cleaned_df.merge(skudf[['Prod Cat', 'Prod Cat Code']], how='left', on='Prod Cat Code') # sku 특징(물품 카테고리) 를 마스터 데이터에 결합
# 필수 열 가져오기
final_cleaned_df = cleaned_df
final_cleaned_df = final_cleaned_df[['Prod Cat','Material','Qty','Customer ID','Clusters',]]
# 고유한 고객 목록 유지, 중복 제거
cust_grouped = final_cleaned_df.groupby(['Customer ID',
'Prod Cat',
'Material',
'Clusters']).sum().reset_index()
## Interaction Matrix
interactions = cust_grouped.groupby(['Customer ID', 'Material'])['Qty'].sum().unstack().fillna(0)
minmaxscaler = preprocessing.MinMaxScaler()
interactions_scaled = minmaxscaler.fit_transform(interactions)
interactions_scaled = pd.DataFrame(interactions_scaled)
interactions_scaled.index = interactions.index
interactions_scaled.columns = interactions.columns
## User Features Matrix
cust_qty = cust_grouped.groupby(['Customer ID', 'Prod Cat'])['Qty'].sum().unstack().fillna(0)
minmaxscaler = preprocessing.MinMaxScaler()
cust_qty_scaled = minmaxscaler.fit_transform(cust_qty)
cust_qty_scaled = pd.DataFrame(cust_qty_scaled)
cust_qty_scaled.index = cust_qty.index
cust_qty_scaled.columns = cust_qty.columns
cust_clus = cust_grouped.groupby(['Customer ID', 'Clusters'])['Clusters'].nunique().unstack().fillna(0)
customer_features = pd.merge(cust_qty_scaled, cust_clus, left_index=True, right_index=True, how='inner')
customer_features = customer_features.rename(columns={0: 'Cluster 0',
1: 'Cluster 1',
2: 'Cluster 2',
3: 'Cluster 3',
4: 'Cluster 4'})
### Item Features Matrix
item_category = pd.DataFrame(cust_grouped.groupby(['Material',
'Prod Cat'])['Qty'].sum().unstack().fillna(0).reset_index().set_index('Material'))
minmaxscaler = preprocessing.MinMaxScaler()
item_category_scaled = minmaxscaler.fit_transform(item_category)
item_category_scaled = pd.DataFrame(item_category_scaled)
item_category_scaled.index = item_category.index
item_category_scaled.columns = item_category.columns
interaction_f = sparse.coo_matrix(interactions_scaled)
user_f = sparse.coo_matrix(customer_features)
item_f = sparse.coo_matrix(item_category_scaled)
mask_size = len(interaction_f.data)
np.random.choice(a=[False, True],
size=mask_size,
p=[.2, .8])
## train, test data
train_interactions, test_interactions = interaction_masking(interaction_f)
user_features = user_f
item_features = item_f
# train
## 모델 파라미터
epochs = 100
alpha = 0.01
n_components = 10
verbose = True
learning_rate = 0.01
n_sampled_items = int(item_features.shape[0] * .1)
biased = False
k_val = 100
model = TensorRec(n_components = n_components,
user_repr_graph = DeepRepresentationGraph(),
item_repr_graph = NormalizedLinearRepresentationGraph(),
loss_graph = WMRBLossGraph(),
biased=biased)
model.fit(train_interactions,
user_features,
item_features,
epochs=epochs,
verbose=False,
alpha=alpha,
n_sampled_items=n_sampled_items,
learning_rate=learning_rate)
predicted_ranks = model.predict_rank(user_features=user_features,
item_features=item_features)
r_at_k_test = recall_at_k(predicted_ranks, test_interactions, k=80)
r_at_k_train = recall_at_k(predicted_ranks, train_interactions, k=80)
print("Recall at @k: Train: {:.2f} Test: {:.2f}".format(r_at_k_train.mean(), r_at_k_test.mean()))
# produce the ranking into a readable table (dataframe it is)
ranks_df = pd.DataFrame(predicted_ranks)
ranks_df.columns = item_category_scaled.index
ranks_df.index = customer_features.index
ranks_df = ranks_df.T
ranks_df.to_csv('./result/ranks_df.csv')
def test_dot_product(self):
model = TensorRec(prediction_graph=DotProductPredictionGraph())
model.fit(self.interactions, self.user_features, self.item_features, epochs=5)
def test_dot_product(self):
model = TensorRec(prediction_graph=DotProductPredictionGraph())
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=5)
def test_fit_fail_batching_dataset(self):
model = TensorRec(n_components=10)
interactions_as_dataset = create_tensorrec_dataset_from_sparse_matrix(self.interactions)
with self.assertRaises(ValueError):
model.fit(interactions_as_dataset, self.user_features, self.item_features, epochs=10, user_batch_size=2)
def test_balanced_wmrb_loss_biased(self):
model = TensorRec(loss_graph=BalancedWMRBLossGraph(), biased=True)
model.fit(self.interactions, self.user_features, self.item_features, epochs=5, n_sampled_items=10)
def test_wmrb_loss(self):
model = TensorRec(loss_graph=WMRBLossGraph())
model.fit(self.interactions, self.user_features, self.item_features, epochs=5, n_sampled_items=10)
def test_rmse_dense_loss_biased(self):
model = TensorRec(loss_graph=RMSEDenseLossGraph(), biased=True)
model.fit(self.interactions, self.user_features, self.item_features, epochs=5)
def test_rmse_loss(self):
model = TensorRec(loss_graph=RMSELossGraph())
model.fit(self.interactions, self.user_features, self.item_features, epochs=5)
def test_wmrb_loss_biased(self):
model = TensorRec(loss_graph=wmrb_loss, biased=True)
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=5)
def test_cos_distance(self):
model = TensorRec(prediction_graph=CosineSimilarityPredictionGraph())
model.fit(self.interactions, self.user_features, self.item_features, epochs=5)
def test_cos_distance(self):
model = TensorRec(prediction_graph=CosineSimilarityPredictionGraph())
model.fit(self.interactions,
self.user_features,
self.item_features,
epochs=5)