def train(train_data,
val_data,
user_list_train_filtered,
user_list_val_filtered,
user_beta_train,
user_beta_val,
k,
dataset,
eta=0.1,
lamb=0.1,
tolerance=1e-4,
num_iter_val=5,
num_total_iter_training=6,
random_seed=786,
kU=None,
cv_flag=True,
verbose=False):
np.random.seed(random_seed)
user_feat = val_data.drop(['user', 'label'], axis=1).values
user_feat_train = train_data.drop(['user', 'label'], axis=1).values
w = np.random.normal(0, 1, user_feat.shape[1])
metrics = Metrics()
metrics.eta_lr = eta
metrics.lamb_reg = lamb
print("running for eta", eta, "and lambda", lamb)
for i in range(num_total_iter_training):
grad, loss = subgradient(w, train_data, user_list_train_filtered,
user_beta_train, k)
grad += lamb * w
w = w - (eta / np.sqrt(i + 1)) * grad
metrics.w_list.append(w)
metrics.loss_opt_list_train.append(loss)
y_scores = user_feat_train.dot(w)
data_true = deepcopy(train_data)
data_true['scores'] = y_scores
data_true = data_true.sort_values(by='scores', ascending=False)
data_true = data_true.reset_index(drop=True)
metrics.micro_auc_rel_k_list_train.append(
compute_micro(data_true, user_list_train_filtered, user_beta_train,
w, k))
if verbose:
print('Epoch', i + 1, 'completed out of', num_total_iter_training,
'for prec@k loss train:', metrics.loss_opt_list_train[-1])
print('Epoch', i + 1, 'completed out of', num_total_iter_training,
'for prec@k grad train:', np.linalg.norm(grad))
# evaluate combined weights
if (cv_flag):
if i % num_iter_val == 0:
y_scores = user_feat.dot(w)
data_true = deepcopy(val_data)
data_true['scores'] = y_scores
data_true = data_true.sort_values(by='scores', ascending=False)
data_true = data_true.reset_index(drop=True)
metrics.micro_auc_rel_k_list_val.append(
compute_micro(data_true, user_list_val_filtered,
user_beta_val, w, k))
if verbose:
print("\n")
print('Epoch', i + 1, 'completed out of',
num_total_iter_training, 'for prec@k loss val:',
metrics.micro_auc_rel_k_list_val[-1])
print("\n")
return metrics, None
def train(train_data,
val_data,
user_list_train_filtered,
user_list_val_filtered,
user_beta_train,
user_beta_val,
k,
eta=0.1,
lamb=0.1,
num_iter_val=5,
num_total_iter_training=6,
n_classifiers=5,
random_seed=786,
verbose=False):
np.random.seed(random_seed)
user_list_val_filtered = user_list_train_filtered[
0:int(0.2 * len(user_list_train_filtered))]
user_list_train_filtered = list(
set(user_list_train_filtered) - set(user_list_val_filtered))
val_data = train_data[train_data['user'].isin(user_list_val_filtered)]
train_data = train_data[train_data['user'].isin(user_list_train_filtered)]
metrics = Metrics()
metrics.eta_lr = eta
metrics.lamb_reg = lamb
classifier_list = []
kf = KFold(n_splits=n_classifiers, shuffle=True)
features = train_data.drop(['user', 'label'], axis=1)
labels = train_data['label']
for _, split_indices in kf.split(features):
split_features = features.iloc[split_indices].values
split_labels = labels.iloc[split_indices].values
num_examples = split_features.shape[0]
w = np.random.normal(0, 1, (split_features.shape[1], ))
w = w / np.linalg.norm(w)
for num_iter in np.arange(num_total_iter_training):
scores = sigmoid(np.dot(split_features, w))
loss = -1 / num_examples * np.sum(split_labels * np.log(scores) +
(1 - split_labels) *
np.log(1 - scores))
print("loss is ", loss)
dLdwx = (scores - split_labels) * scores * (1 - scores)
grad = 1 / num_examples * np.sum(
dLdwx.reshape(-1, 1) * split_features)
grad += lamb * w
print("grad is ", np.linalg.norm(grad))
print("\n")
w = w - (eta / np.sqrt(num_iter + 1)) * grad
accuracy = np.sum(split_labels * (scores > 0.5) + (1 - split_labels) *
(scores < 0.5))
print('accuracy: {}'.format(accuracy / num_examples))
classifier_list.append(w)
print('eta is ', eta, 'and lambda is ', lamb)
print('\n')
classifiers_with_metrics = []
for w in classifier_list:
user_feat = val_data.drop(['user', 'label'], axis=1).values
y_scores = user_feat.dot(w)
data_true = deepcopy(val_data)
data_true['scores'] = y_scores
data_true = data_true.sort_values(by='scores', ascending=False)
data_true = data_true.reset_index(drop=True)
metric = compute_micro(data_true, user_list_val_filtered,
user_beta_train, w, k)
classifiers_with_metrics.append((metric, w))
classifiers_with_metrics.sort(reverse=True, key=lambda x: x[0])
combined_w = classifiers_with_metrics[0][1]
for _, w in classifiers_with_metrics[1:]:
combined_w = merge_micro(val_data, combined_w, w,
user_list_val_filtered, user_beta_train, k)
# create dummy metrics
# need weights and one validation loss for the "best iter" logic
metrics = Metrics()
metrics.w_list.append(combined_w)
metrics.micro_auc_rel_k_list_val.append(0)
metrics.micro_auc_rel_k_list_train.append(0)
metrics.loss_opt_list_train.append(0)
return metrics, None