forked from Dingseewhole/Robust_Deconfounder_master
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathIPS.py
161 lines (135 loc) · 7.62 KB
/
IPS.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
import os
import numpy as np
import random
import torch
import torch.nn as nn
from model import *
import arguments
import utils.load_dataset
import utils.data_loader
import utils.metrics
from utils.early_stop import EarlyStopping, Stop_args
import time
def setup_seed(seed):
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed)
random.seed(seed)
def para(args):
if args.dataset == 'yahooR3':
args.training_args = {'batch_size': 1024, 'epochs': 500, 'patience': 60, 'block_batch': [6000, 500]}
args.base_model_args = {'emb_dim': 10, 'learning_rate': 0.00001, 'weight_decay': 0}
elif args.dataset == 'coat':
args.training_args = {'batch_size': 128, 'epochs': 500, 'patience': 60, 'block_batch': [64, 64]}
args.base_model_args = {'emb_dim': 10, 'learning_rate': 1e-5, 'weight_decay': 1}
else:
print('invalid arguments')
os._exit()
def both_test(loader, model_name, testname, K = 5, dataset = "None",device='cuda'):
test_users = torch.empty(0, dtype=torch.int64).to(device)
test_items = torch.empty(0, dtype=torch.int64).to(device)
test_pre_ratings = torch.empty(0).to(device)
test_ratings = torch.empty(0).to(device)
ndcg_ratings = torch.empty(0).to(device)
ndcg_item = torch.empty(0).to(device)
ut_dict={}
pt_dict={}
for batch_idx, (users, items, ratings) in enumerate(loader):
pre_ratings = model_name(users, items)
for i,u in enumerate(users):
try:
ut_dict[u.item()].append(ratings[i].item())
pt_dict[u.item()].append(pre_ratings[i].item())
except:
ut_dict[u.item()]=[ratings[i].item()]
pt_dict[u.item()]=[pre_ratings[i].item()]
test_users = torch.cat((test_users, users))
test_items = torch.cat((test_items, items))
test_pre_ratings = torch.cat((test_pre_ratings, pre_ratings))
test_ratings = torch.cat((test_ratings, ratings))
pos_mask = torch.where(ratings>=torch.ones_like(ratings), torch.arange(0,len(ratings)).float().to(device), 100*torch.ones_like(ratings))
pos_ind = pos_mask[pos_mask != 100].long()
users_ndcg = torch.index_select(users, 0, pos_ind)
test_results = utils.metrics.evaluate(test_pre_ratings, test_ratings, ['MSE', 'NLL', 'AUC', 'Recall_Precision_NDCG@'], users=test_users, items=test_items, NDCG=None, UAUC=(ut_dict, pt_dict))
U = test_results['UAUC']
N = test_results['NDCG']
print(f'The performance of IPS on uniform data is: UAUC = {U} NDCG@5 = {N}')
return test_results
def train_and_eval(train_data, unif_train_data, val_data, test_data, device = 'cuda',
model_args: dict = {'emb_dim': 64, 'learning_rate': 0.01, 'weight_decay': 0.1},
training_args: dict = {'batch_size': 1024, 'epochs': 100, 'patience': 20, 'block_batch': [1000, 100]}):
# build data_loader.
train_loader = utils.data_loader.Block(train_data, u_batch_size=training_args['block_batch'][0], i_batch_size=training_args['block_batch'][1], device=device)
val_loader = utils.data_loader.DataLoader(utils.data_loader.Interactions(val_data), batch_size=training_args['batch_size'], shuffle=False, num_workers=0)
test_loader = utils.data_loader.DataLoader(utils.data_loader.Interactions(test_data), batch_size=training_args['batch_size'], shuffle=False, num_workers=0)
def Naive_Bayes_Propensity(train, unif):
# follow [1] Jiawei Chen et, al, AutoDebias: Learning to Debias for Recommendation 2021SIGIR and
# [2] Tobias Schnabel, et, al, Recommendations as Treatments: Debiasing Learning and Evaluation
P_Oeq1 = train._nnz() / (train.size()[0] * train.size()[1])
y_unique = torch.unique(train._values())
P_y_givenO = torch.zeros(y_unique.shape).to(device)
P_y = torch.zeros(y_unique.shape).to(device)
for i in range(len(y_unique)):
P_y_givenO[i] = torch.sum(train._values() == y_unique[i]) / torch.sum(torch.ones(train._values().shape).to(device))
P_y[i] = torch.sum(unif._values() == y_unique[i]) / torch.sum(torch.ones(unif._values().shape).to(device))
Propensity = P_y_givenO * P_Oeq1 / P_y
return y_unique, Propensity
y_unique, Propensity = Naive_Bayes_Propensity(train_data, unif_train_data)
InvP = torch.reciprocal(Propensity)
# data shape
n_user, n_item = train_data.shape
# model and its optimizer.
model = MF(n_user, n_item, dim=model_args['emb_dim'], dropout=0).to(device)
optimizer = torch.optim.SGD(model.parameters(), lr=model_args['learning_rate'], weight_decay=0)
# loss_criterion
none_criterion = nn.MSELoss(reduction='none')
# begin training
stopping_args = Stop_args(patience=training_args['patience'], max_epochs=training_args['epochs'])
early_stopping = EarlyStopping(model, **stopping_args)
for epo in range(early_stopping.max_epochs):
for u_batch_idx, users in enumerate(train_loader.User_loader):
for i_batch_idx, items in enumerate(train_loader.Item_loader):
model.train()
users_train, items_train, y_train = train_loader.get_batch(users, items)
y_hat = model(users_train, items_train)
cost = none_criterion(y_hat, y_train)
weight = torch.ones(y_train.shape).to(device)
for i in range(len(y_unique)):
weight[y_train == y_unique[i]] = InvP[i]
loss = torch.sum(weight * cost) + model_args['weight_decay'] * model.l2_norm(users, items)
optimizer.zero_grad()
loss.backward()
optimizer.step()
model.eval()
with torch.no_grad():
train_pre_ratings = torch.empty(0).to(device)
train_ratings = torch.empty(0).to(device)
for u_batch_idx, users in enumerate(train_loader.User_loader):
for i_batch_idx, items in enumerate(train_loader.Item_loader):
users_train, items_train, y_train = train_loader.get_batch(users, items)
pre_ratings = model(users_train, items_train)
train_pre_ratings = torch.cat((train_pre_ratings, pre_ratings))
train_ratings = torch.cat((train_ratings, y_train))
# validation metrics
val_pre_ratings = torch.empty(0).to(device)
val_ratings = torch.empty(0).to(device)
for batch_idx, (users, items, ratings) in enumerate(val_loader):
pre_ratings = model(users, items)
val_pre_ratings = torch.cat((val_pre_ratings, pre_ratings))
val_ratings = torch.cat((val_ratings, ratings))
val_results = utils.metrics.evaluate(val_pre_ratings, val_ratings, ['MSE', 'NLL', 'AUC'])
if early_stopping.check([val_results['AUC']], epo):
break
print('Loading {}th epoch'.format(early_stopping.best_epoch))
model.load_state_dict(early_stopping.best_state)
test_results = both_test(test_loader, model, ('CF', 'IPS', 'unbias'), K=5, dataset=args.dataset, device=device)
return 0
if __name__ == "__main__":
args = arguments.parse_args()
para(args)
setup_seed(args.seed)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
train, unif_train, validation, test, n, m = utils.load_dataset.load_dataset(data_name=args.dataset, type = 'explicit', seed = args.seed, device=device)
train_and_eval(train, unif_train, validation, test, device, model_args = args.base_model_args, training_args = args.training_args)