from recommenders.recommender import Recommender
# HR10 = 0.07
# class Net(nn.Module):
# def __init__(self, features_len, output_len):
# super(Net, self).__init__()
# self.fc1 = nn.Linear(features_len, 150)
# self.fc2 = nn.Linear(150, 100)
# self.fc3 = nn.Linear(100, output_len)
# self.fc4 = nn.Linear(output_len, output_len+200)
# self.dropout = nn.Dropout(p=0.5)
# def forward(self, x):
# x = F.relu(self.fc1(x))
# x = self.dropout(x)
# x = F.relu(self.fc2(x))
# x = self.dropout(x)
# x = F.relu(self.fc3(x))
# return self.fc4(x)
# HR10 = 0.06
# class Net(nn.Module):
# def __init__(self, features_len, output_len):
# super(Net, self).__init__()
# self.fc1 = nn.Linear(features_len, 150)
# self.fc2 = nn.Linear(150, 100)
# self.fc3 = nn.Linear(100, output_len)
# self.fc4 = nn.Linear(output_len, output_len+150)
# self.dropout = nn.Dropout(p=0.5)
# def forward(self, x):
# x = F.relu(self.fc1(x))
# x = self.dropout(x)
# x = F.relu(self.fc2(x))
# x = self.dropout(x)
# x = F.relu(self.fc3(x))
# x = self.dropout(x)
# return self.fc4(x)
# Softmax very bad choice for multiclassification
# class Net(nn.Module):
# def __init__(self, features_len, output_len):
# super(Net, self).__init__()
# self.fc1 = nn.Linear(features_len, 150)
# self.fc2 = nn.Linear(150, 100)
# self.fc3 = nn.Linear(100, output_len)
# self.fc4 = nn.Linear(output_len, output_len+200)
# self.dropout = nn.Dropout(p=0.5)
# self.softmax = nn.Softmax()
# def forward(self, x):
# x = F.relu(self.fc1(x))
# x = self.dropout(x)
# x = F.relu(self.fc2(x))
# x = self.dropout(x)
# x = F.relu(self.fc3(x))
# x = self.fc4(x)
# x = self.softmax(x)
# return x
# HR10 = 0.116 EPOCH 20000
class Net(nn.Module):
def __init__(self, features_len, output_len):
super(Net, self).__init__()
self.fc1 = nn.Linear(features_len, 150)
self.fc2 = nn.Linear(150, 100)
self.fc3 = nn.Linear(100, output_len)
self.fc4 = nn.Linear(output_len, output_len+200)
self.dropout = nn.Dropout(p=0.5)
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.dropout(x)
x = F.relu(self.fc2(x))
x = self.dropout(x)
x = F.relu(self.fc3(x))
return self.fc4(x)
# A lot slower than ReLU
# class Net(nn.Module):
# def __init__(self, features_len, output_len):
# super(Net, self).__init__()
# self.fc1 = nn.Linear(features_len, 150)
# self.fc2 = nn.Linear(150, 100)
# self.fc3 = nn.Linear(100, output_len)
# self.fc4 = nn.Linear(output_len, output_len+200)
# self.dropout = nn.Dropout(p=0.5)
# self.prelu = nn.PReLU()
# def forward(self, x):
# x = self.fc1(x)
# x = self.prelu(x)
# x = self.dropout(x)
# x = self.fc2(x)
# x = self.prelu(x)
# x = self.dropout(x)
# x = self.fc3(x)
# x = self.prelu(x)
# return self.fc4(x)
class NNRecommender(Recommender):
"""
Linear recommender class based on user and item features.
"""
def __init__(self, seed=6789, n_neg_per_pos=5, n_epochs=20000, lr=0.01):
"""
Initialize base recommender params and variables.
"""
self.model = None
self.n_neg_per_pos = n_neg_per_pos
self.recommender_df = pd.DataFrame(columns=['user_id', 'item_id', 'score'])
self.users_df = None
self.user_features = None
self.seed = seed
self.rng = np.random.RandomState(seed=seed)
self.n_epochs = n_epochs
self.lr = lr
def calculate_accuracy(self, y_true, y_pred):
predictions=(y_pred.argmax(1))
return (predictions == y_true).sum().float() / len(y_true)
def round_tensor(self, t, decimal_places=3):
return round(t.item(), decimal_places)
def fit(self, interactions_df, users_df, items_df):
"""
Training of the recommender.
:param pd.DataFrame interactions_df: DataFrame with recorded interactions between users and items
defined by user_id, item_id and features of the interaction.
:param pd.DataFrame users_df: DataFrame with users and their features defined by user_id and the user feature columns.
:param pd.DataFrame items_df: DataFrame with items and their features defined by item_id and the item feature columns.
"""
interactions_df = interactions_df.copy()
# Prepare users_df and items_df
# (optional - use only if you want to train a hybrid model with content-based features)
users_df, user_features = prepare_users_df(interactions_df)
self.users_df = users_df
self.user_features = user_features
items_df, item_features = prepare_items_df(interactions_df)
items_df = items_df.loc[:, ['item_id'] + item_features]
X = items_df[['term_WinterVacation', 'term_Easter', 'term_OffSeason', 'term_HighSeason', 'term_LowSeason', 'term_MayLongWeekend', 'term_NewYear', 'term_Christmas', 'rate_plan_Standard', 'rate_plan_Nonref', 'room_segment_[0-160]', 'room_segment_[160-260]', 'room_segment_[260-360]', 'room_segment_[360-500]', 'room_segment_[500-900]', 'n_people_bucket_[1-1]', 'n_people_bucket_[2-2]', 'n_people_bucket_[3-4]', 'n_people_bucket_[5-inf]', 'weekend_stay_True', 'weekend_stay_False']]
y = items_df[['item_id']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=self.seed)
X_train = torch.from_numpy(X_train.to_numpy()).float()
y_train = torch.squeeze(torch.from_numpy(y_train.to_numpy()).long())
X_test = torch.from_numpy(X_test.to_numpy()).float()
y_test = torch.squeeze(torch.from_numpy(y_test.to_numpy()).long())
self.net = Net(X_train.shape[1], items_df['item_id'].unique().size)
optimizer = optim.Adam(self.net.parameters(), lr=self.lr)
criterion = nn.CrossEntropyLoss()
for epoch in range(self.n_epochs):
y_pred = self.net(X_train)
y_pred = torch.squeeze(y_pred)
train_loss = criterion(y_pred, y_train)
if epoch % 1000 == 0:
y_test_pred = self.net(X_test)
y_test_pred = torch.squeeze(y_test_pred)
test_loss = criterion(y_test_pred, y_test)
print(
f'''epoch {epoch}
Train set - loss: {self.round_tensor(train_loss)}
Test set - loss: {self.round_tensor(test_loss)}
''')
optimizer.zero_grad()
train_loss.backward()
optimizer.step()
def recommend(self, users_df, items_df, n_recommendations=1):
"""
Serving of recommendations. Scores items in items_df for each user in users_df and returns
top n_recommendations for each user.
:param pd.DataFrame users_df: DataFrame with users and their features for which recommendations should be generated.
:param pd.DataFrame items_df: DataFrame with items and their features which should be scored.
:param int n_recommendations: Number of recommendations to be returned for each user.
:return: DataFrame with user_id, item_id and score as columns returning n_recommendations top recommendations
for each user.
:rtype: pd.DataFrame
"""
# Clean previous recommendations (iloc could be used alternatively)
self.recommender_df = self.recommender_df[:0]
# Prepare users_df and items_df
# (optional - use only if you want to train a hybrid model with content-based features)
users_df = users_df.loc[:, 'user_id']
users_df = pd.merge(users_df, self.users_df, on=['user_id'], how='left').fillna(0)
# items_df, item_features = prepare_items_df(items_df)
# items_df = items_df.loc[:, ['item_id'] + item_features]
# Score the items
recommendations = pd.DataFrame(columns=['user_id', 'item_id', 'score'])
for ix, user in users_df.iterrows():
prep_user = torch.from_numpy(user[['user_term_WinterVacation', 'user_term_Easter', 'user_term_OffSeason', 'user_term_HighSeason', 'user_term_LowSeason', 'user_term_MayLongWeekend', 'user_term_NewYear', 'user_term_Christmas', 'user_rate_plan_Standard', 'user_rate_plan_Nonref', 'user_room_segment_[0-160]', 'user_room_segment_[160-260]', 'user_room_segment_[260-360]', 'user_room_segment_[360-500]', 'user_room_segment_[500-900]', 'user_n_people_bucket_[1-1]', 'user_n_people_bucket_[2-2]', 'user_n_people_bucket_[3-4]', 'user_n_people_bucket_[5-inf]', 'user_weekend_stay_True', 'user_weekend_stay_False']].to_numpy()).float()
scores = self.net(prep_user).detach().numpy()
chosen_ids = np.argsort(-scores)[:n_recommendations]
recommendations = []
for item_id in chosen_ids:
recommendations.append(
{
'user_id': user['user_id'],
'item_id': item_id,
'score': scores[item_id]
}
)
user_recommendations = pd.DataFrame(recommendations)
self.recommender_df = pd.concat([self.recommender_df, user_recommendations])
return self.recommender_df
# Fit method
# nn_recommender = NNRecommender(10000, 0.02)
# nn_recommender.fit(interactions_df.head(1000), None, None)
# nn_recommender.fit(interactions_df, None, None)
