def train_ffm(self,
trainset_path,
testset_path,
model_save_path,
suffix=""):
"""
self.config_params["workdir"] + "ffm/ffm_train_java.txt"
self.config_params["workdir"] + "ffm/ffm_test_java.txt"
self.config_params["workdir"] + "ffm/ffm.txt"
:return:
"""
ffm_model = xl.create_ffm() # Use field-aware factorization machine
ffm_model.disableNorm() # instance-wise normalization
ffm_model.setTrain(trainset_path) # Training data
ffm_model.setValidate(testset_path) # Validation data
ffm_model.setSigmoid()
param = self.config_params[self.algo]
if "ffm" in param:
param = param["ffm"]
if "phase" in param:
param.pop("phase")
if "model_cnt" in param:
param.pop("model_cnt")
model_txt_path = model_save_path + "ffm_{}{}.txt".format(
self.config_params["channelid"], suffix)
model_binary_path = model_save_path + "ffm_{}{}.out".format(
self.config_params["channelid"], suffix)
ffm_model.setTXTModel(model_txt_path)
ffm_model.fit(param, model_binary_path)
self.evaluation([model_binary_path], trainset_path, testset_path)
def train_ffm(self, trainset_path, testset_path, model_save_path):
"""
self.config_params["workdir"] + "ffm/ffm_train_java.txt"
self.config_params["workdir"] + "ffm/ffm_test_java.txt"
self.config_params["workdir"] + "ffm/ffm.txt"
:return:
"""
ffm_model = xl.create_ffm() # Use field-aware factorization machine
ffm_model.disableNorm() # instance-wise normalization
ffm_model.setTrain(trainset_path) # Training data
ffm_model.setValidate(testset_path) # Validation data
ffm_model.setSigmoid()
param = self.config_params["xgboost_plus_ffm"]["ffm"]
model_txt_path = model_save_path + "ffm.txt"
model_binary_path = model_save_path + "ffm.out"
ffm_model.setTXTModel(model_txt_path)
ffm_model.fit(param, model_binary_path)
ffm_model.setTest(trainset_path)
ffm_model.predict(
model_binary_path,
self.config_params["workdir"][platform.system()] +
"ffm/train_predict.txt")
ffm_model.setTest(testset_path)
ffm_model.predict(
model_binary_path,
self.config_params["workdir"][platform.system()] +
"ffm/test_predict.txt")
def evaluation(self, model_binary_path_list, trainset_path, testset_path):
ffm_model = xl.create_ffm() # Use field-aware factorization machine
ffm_model.disableNorm() # instance-wise normalization
ffm_model.setTrain(trainset_path) # Training data
ffm_model.setValidate(testset_path) # Validation data
ffm_model.setSigmoid()
workdir = self.config_params["workdir"][platform.system()]
if len(model_binary_path_list) > 1:
for idx, model_binary_path in enumerate(model_binary_path_list):
ffm_model.setTest(trainset_path)
ffm_model.predict(
model_binary_path,
workdir + "ffm/train_predict_{}.txt".format(idx + 1))
ffm_model.setTest(testset_path)
ffm_model.predict(
model_binary_path,
workdir + "ffm/test_predict_{}.txt".format(idx + 1))
else:
ffm_model.setTest(trainset_path)
ffm_model.predict(model_binary_path_list[0],
workdir + "ffm/train_predict.txt")
ffm_model.setTest(testset_path)
ffm_model.predict(model_binary_path_list[0],
workdir + "ffm/test_predict.txt")
def ffm_predict():
ffm_model = xl.create_ffm()
ffm_model.setOnDisk()
ffm_model.setTest('encoded_test_file.ffm')
ffm_model.setSigmoid()
ffm_model.predict('model/model2.out', 'output/output2.res')
def train(k, lam, lr, early, epoch, train_fname, valid_fname, test_fname,
pred_fname):
model_fname = "/tmp/model.out"
param = {
'task': 'reg',
'lr': 0.1,
'lambda': 1,
'metric': 'rmse',
'opt': 'adagrad',
'k': 60,
'stop_window': 1,
'epoch': 1000,
}
param['k'] = k
param['lambda'] = lam
param['lr'] = lr
param['epoch'] = epoch
model = xl.create_ffm()
model.setTrain(train_fname)
model.setValidate(valid_fname)
model.setTest(test_fname)
model.disableNorm()
if not early:
model.disableEarlyStop()
model.fit(param, model_fname)
model.predict(model_fname, pred_fname)
def main():
'''
前期准备工作
小样本用 data_s/ res_s/ 全部用data/ res/
'''
if datasetflag == 'all':
raw_data_name='data.csv'
inputpath='data/'
outputpath='res/' + 'FFM_' + datetime.now().strftime("%Y%m%d_%H%M%S")+'/'
else:
raw_data_name='data_s.csv'
inputpath='data_s/'
outputpath='res_s/' + 'FFM_' + datetime.now().strftime("%Y%m%d_%H%M%S")+'/'
os.mkdir(outputpath)
''' Preprocess '''
if preprocessflag == 'on':
preprocess.preprocess(inputfilename=raw_data_name,outputpath=inputpath)
if FFM_preprocessflag == 'on':
# preprocess.FFM_preprocess(inputpath)
preprocess.convertion(inputpath)
''' training '''
ffm_model = xl.create_ffm()
ffm_model.setTrain(inputpath+'train.txt')
ffm_model.setValidate(inputpath+'evals.txt')
ffm_model.fit(parameter, outputpath+'model.out')
# ffm_model.cv(parameter)
ffm_model.setTest(inputpath+'test.txt')
ffm_model.setSigmoid()
ffm_model.predict(outputpath+'model.out',outputpath+'res.txt')
turn txt to final result
def FFMtrain(self):
ffm_model = xl.create_ffm()
param = {
'task': 'binary',
'lr': 0.02,
'lambda': 0.002,
'metric': 'auc'
}
ffm_model.setTrain("./data/train_ffm.csv")
ffm_model.fit(param, "./data/model.out")
def train_ffm(
train_libffm_path, test_libffm_path, model_path, pred_path, param):
print_log(f'Training ffm from {train_libffm_path}')
ffm = xl.create_ffm()
ffm.setTrain(train_libffm_path)
ffm.fit(param, model_path)
ffm.setSigmoid()
ffm.setTest(test_libffm_path)
ffm.predict(model_path, pred_path)
def test(self):
ffm_model = xl.create_ffm()
# Prediction task
ffm_model.setTest(self.test_data_path) # Set the path of test dataset
ffm_model.setSigmoid() # Convert output to 0-1
# Start to predict
# The output result will be stored in output.txt
res = ffm_model.predict(os.path.join(self.save_path, 'ffm.model'))
print()
def __init__(self, model_type):
assert model_type in ["FM","FFM","linear"] # 只能是这三种模型
self.model_type = model_type
if self.model_type == "FM":
self.model = xl.create_fm()
elif self.model_type == "FFM":
self.model = xl.create_ffm()
else: # 采用默认的线性模型
self.model = xl.create_linear()
def creat_model(model_type): # 创建模型对象
if model_type == "FM":
model = xl.create_fm()
elif model_type == "FFM":
model = xl.create_ffm()
else: # 采用默认的线性模型
model = xl.create_linear()
return model
def FFMtest(self):
ffm_model = xl.create_ffm()
param = {
'task': 'binary',
'lr': 0.02,
'lambda': 0.002,
'metric': 'auc'
}
ffm_model.setTest("./data/test_ffm.csv")
ffm_model.setSigmoid()
ffm_model.predict("./data/model.out", "./data/output.txt")
def done(op_type='istrain'):
### 开始训练
ffm_model = xl.create_ffm()
logging.debug('设置参数')
if op_type == 'istrain':
logging.debug("开始训练")
ffm_model.setTrain(FLAGS.tmp_data_path + 'ont_hot_train.libffm.csv')
ffm_model.setValidate(FLAGS.tmp_data_path + 'ont_hot_vali.libffm.csv')
ffm_model.disableEarlyStop()
ffm_model.fit(param, FLAGS.tmp_data_path + 'ffm_model.out')
logging.debug("to save validation predictions ...")
# ret=dump(ffm_model, FLAGS.out_data_path+'1-'+'-ffm_model.model.joblib_dat')
# logging.debug(ret)
ffm_model.show()
logging.debug(ffm_model)
elif op_type == 'cv':
logging.debug("开始 CV")
ffm_model.setTrain(FLAGS.tmp_data_path + 'ont_hot_train.libffm.csv')
ffm_model.cv(param)
logging.debug("to save validation predictions ...")
logging.debug(ffm_model)
else:
# ffm_model = load(FLAGS.out_data_path+'1-'+'-ffm_model.model.joblib_dat')
# logging.debug(gbm.get_params())
### 线下预测
test_save = FLAGS.tmp_data_path + 'ont_hot_test.libffm.csv'
logging.debug("预测")
ffm_model.setTest(test_save) # Test data
ffm_model.setSigmoid() # Convert output to 0-1
ffm_model.predict(FLAGS.tmp_data_path + 'ffm_model.out',
FLAGS.tmp_data_path + 'output.txt')
ffm_model.show()
fp = open(FLAGS.tmp_data_path + 'output.txt', 'r')
dtrain_predprob = fp.readlines()
logging.debug(ffm_model)
y_pred = [
round(float(value.replace('\n', '')), 4)
for value in dtrain_predprob
]
logging.debug('-' * 30)
y_pred = np.array(y_pred).reshape(-1, 1)
logging.debug(y_pred.shape)
test_id = pd.read_csv(FLAGS.test_id_path + 'test_id.csv')
logging.debug(test_id['id'].shape)
test_id['id'] = test_id['id'].map(int)
test_id['click'] = y_pred
test_id.to_csv(FLAGS.out_data_path + '1-' + 'ffm_model.test.csv',
index=False)
def createffm():
ffm_model = xl.create_ffm()
# ffm_model.setOnDisk()
ffm_model.setTrain(train_path)
ffm_model.setValidate(test_path)
param = {
'lambda': 0.00002,
'lr': 0.05,
'task': 'binary',
'k': 8,
'metric': 'auc'
}
ffm_model.fit(param, "./model.out")
def eval_yyh(self, model_binary_path_list, n, testset_path):
ffm_model = xl.create_ffm() # Use field-aware factorization machine
ffm_model.disableNorm() # instance-wise normalization
# ffm_model.setTrain(trainset_path) # Training data
ffm_model.setValidate(testset_path) # Validation data
ffm_model.setSigmoid()
workdir = self.config_params["workdir"][platform.system()]
# ffm_model.setTest(trainset_path)
# ffm_model.predict(model_binary_path_list[0], workdir + "ffm/train_predict.txt")
ffm_model.setTest(testset_path)
ffm_model.predict(model_binary_path_list[0],
workdir + "ffm/test_predict_yyh_{}.txt".format(n))
def ffm_setting():
# Training task
ffm_model = xl.create_ffm() # Use field-aware factorization machine
ffm_model.setTrain("./small_train.txt") # Training data
ffm_model.setValidate("./small_test.txt") # Validation data
# param:
# 0. binary classification
# 1. learning rate : 0.2
# 2. regular lambda : 0.002
param = {'task': 'binary', 'lr': 0.2, 'lambda': 0.002}
# Train model
ffm_model.fit(param, "./model.out")
def train_ffm(self,
trainset_path,
testset_path,
model_save_path,
suffix=""):
"""
self.config_params["workdir"] + "ffm/ffm_train_java.txt"
self.config_params["workdir"] + "ffm/ffm_test_java.txt"
self.config_params["workdir"] + "ffm/ffm.txt"
:return:
"""
ffm_model = xl.create_ffm() # Use field-aware factorization machine
ffm_model.disableNorm() # instance-wise normalization
ffm_model.setTrain(trainset_path) # Training data
ffm_model.setValidate(testset_path) # Validation data
ffm_model.setSigmoid()
param = self.config_params[self.algo]
if "ffm" in param:
param = param["ffm"]
if "phase" in param:
param.pop("phase")
if "model_cnt" in param:
param.pop("model_cnt")
model_txt_path = model_save_path + "ffm{}.txt".format(suffix)
model_binary_path = model_save_path + "ffm{}.out".format(suffix)
ffm_model.setTXTModel(model_txt_path)
ffm_model.fit(param, model_binary_path)
#self.evaluation([model_binary_path], trainset_path, testset_path)
with open(
'/data/yangyuhan/workspace/ctr/hdfs_ctr/ffm/ffm_test_python.txt',
"r",
encoding="utf-8") as file_read:
data = [line.split(' ') for line in file_read]
field_all = [str(i) + ":" for i in range(28)]
for i in range(len(field_all)):
field = field_all[i]
test_yyh_path = self.config_params["workdir"][
platform.system()] + 'ffm/ffm_test_python_yyh_{}.txt'.format(i)
with open(test_yyh_path, "w", encoding="utf-8") as file_write:
for items in data:
tmp = []
for it in items:
if not it.startswith(field):
tmp.append(it)
file_write.write(" ".join([str(l) for l in tmp]))
self.eval_yyh([model_binary_path], i, test_yyh_path)
def __init__(self,
URM_train,
train_svm_file_path,
approximate_recommender: BaseRecommender,
ICM_train=None,
UCM_train=None,
item_feature_fields=None,
user_feature_fields=None,
valid_svm_file_path=None,
max_items_to_predict=1000,
model_filename="model.out",
model_type="ffm",
temp_relative_folder="temp/",
verbose=True):
self.ICM_train = ICM_train
self.UCM_train = UCM_train
user_fields = np.full(shape=URM_train.shape[0], fill_value=0)
item_fields = np.full(shape=URM_train.shape[1], fill_value=1)
if item_feature_fields is not None:
item_feature_fields = item_feature_fields + 2
if user_feature_fields is not None:
user_feature_fields = user_feature_fields + np.max(
item_feature_fields) + 1
self.fields = np.concatenate([
user_fields, item_fields, item_feature_fields, user_feature_fields
])
self.approximate_recommender = approximate_recommender
self.max_items_to_predict = max_items_to_predict
# Set path of temp folder and model_path
root_path = get_project_root_path()
fm_data_path = os.path.join(root_path, "resources", "ffm_data")
self.temp_folder = os.path.join(fm_data_path, temp_relative_folder)
self.model_folder = os.path.join(fm_data_path, "model")
self.model_path = os.path.join(self.model_folder, model_filename)
if model_type == "ffm":
self.model = xl.create_ffm()
elif model_type == "fm":
self.model = xl.create_fm()
else:
raise ValueError(
"model_type is inexistent, choose between ffm and fm")
self.model.setTrain(train_svm_file_path)
if valid_svm_file_path is not None:
self.model.setValidate(valid_svm_file_path)
super().__init__(URM_train, verbose)
def predict(self, path_tst, model_path, xlfm_params=XLFM_PARAMS_DEFAULT):
submission_path = '%s/submission-%d.csv' % (self.artifacts_dir,
int(time()))
ffm_model = xl.create_ffm()
ffm_model.setTest(path_tst)
ffm_model.setSigmoid()
ffm_model.predict(model_path, submission_path)
with open(submission_path) as fp:
yp = [float(l.strip()) for l in fp]
df = pd.DataFrame({'id': list(range(len(yp))), 'target': yp})
df['target'] = df['target'].astype(np.float32)
self.logger.info('yp mean %.3lf' % df['target'].mean())
self.logger.info('%d rows' % len(df['target']))
df.to_csv(submission_path, index=False)
self.logger.info('Saved %s' % submission_path)
def _train(self, params):
ffm_model = xl.create_ffm()
ffm_model.setTrain(os.path.join(self.data_dir, self.train_name))
print(params)
ffm_model.cv(params)
ffm_model.fit(params, os.path.join(self.model_dir, self.model_name))
ffm_model.setTest(os.path.join(self.data_dir, self.test_name))
ffm_model.predict(os.path.join(self.model_dir, self.model_name),
os.path.join(self.submission_dir, 'ffmoutput.txt'))
# wait for the answer of how to get loss value in xlearn
cv_error = 0
return cv_error, params
def xl_objective(params):
start = time()
xl_objective.i+=1
params['task'] = 'reg'
params['metric'] = 'rmse'
params['stop_window'] = 3
# remember hyperopt casts as floats
params['epoch'] = int(params['epoch'])
params['k'] = int(params['k'])
xl_model = xl.create_ffm()
xl_model.setTrain(train_data_file)
# xl_model.setValidate(valid_data_file_opt)
xl_model.setTest(valid_data_file)
# xl_model.setQuiet()
xl_model.fit(params, xlmodel_fname_tmp)
xl_model.predict(xlmodel_fname_tmp, xlpreds_fname_tmp)
preds = np.loadtxt(xlpreds_fname_tmp)
df_preds['interest'] = preds
df_ranked = df_preds.sort_values(['user_id_hash', 'interest'],
ascending=[False, False])
df_ranked = (df_ranked
.groupby('user_id_hash')['coupon_id_hash']
.apply(list)
.reset_index())
recomendations_dict = pd.Series(df_ranked.coupon_id_hash.values,
index=df_ranked.user_id_hash).to_dict()
actual = []
pred = []
for k,_ in recomendations_dict.items():
actual.append(list(interactions_valid_dict[k]))
pred.append(list(recomendations_dict[k]))
score = mapk(actual,pred)
end = round((time() - start)/60.,2)
print("INFO: iteration {} was completed in {} min. Score {:.3f}".format(xl_objective.i, end, score))
return 1-score
def predict():
ffm = xl.create_ffm()
_, _, test = splitFFM()
ffm.setTest(test)
ffm.setSigmoid()
folder = './modelFFM'
model = sorted(glob.glob('./modelFFM/xlModel_*.txt'))[-1]
output = model.replace('Model', 'Output')
ffm.predict(model, output)
df = getMerged('aid', 'uid', kind=2)
df['score'] = np.loadtxt(output)
df.to_csv('submission.csv', index=False)
zipName = '%s/submission.zip' % folder
with zipfile.ZipFile(zipName, 'w') as f:
f.write('submission.csv', compress_type=zipfile.ZIP_DEFLATED)
def predict_behavior_type(variable):
# 获取数据
test = get_new_user_data(variable=variable)
# 预测数据
# 最后处理
test = end_processing(test)
# 调用XGB模型
XGB = joblib.load("C:\\Users\\dell--pc\\Desktop\\RecommenderSystem\\Model\\GbdtFFmFit\\XGB_FFM.model")
# 获取叶子节点数据
new_test = XGB.apply(test.values)
# 转换数据为ffm需要的格式 DMatrix
new_test = xlearn.DMatrix(new_test)
# 调用FFM模型
ffm_model = xlearn.create_ffm()
ffm_model.setSign()
ffm_model.setQuiet()
ffm_model.setOnDisk()
ffm_model.setTest(new_test)
predict_behavior_type = ffm_model.predict(
"C:\\Users\\dell--pc\\Desktop\\RecommenderSystem\\Model\\GbdtFFmFit\\model_dm.out")
data_result = pd.DataFrame()
data_result['user_id'] = test.user_id
data_result['category_id'] = test.category_id
data_result['item_id'] = test.item_id
data_result['predict_result'] = predict_behavior_type
data_result['predict_result'] = data_result['predict_result'].apply(lambda x: random.randint(0,1))
data_result = data_result.loc[data_result.predict_result == 1]
data_result['predict_result'] = connect_item_name(list(data_result['item_id']))
if variable=='1':
predict_result_to_Bmob(data_result[:2])
else:
engine = create_engine("mysql+pymysql://root:123456@localhost:3306/mysql?charset=utf8")
data_result = data_result[:3]
data_result.to_sql(name='predict_result_gbdt_java', con=engine, if_exists='replace',
index=False, index_label=False, chunksize=5000,
dtype={
'user_id':VARCHAR(length=20),
'category_id':VARCHAR(length=20),
'item_id':VARCHAR(length=20),
'predict_result':VARCHAR(length=20)
})
def fit(self,
df,
label,
eva_df=None,
eva_label=None,
path='datasource/train.ffm',
overwrite_path=True,
eva_path='datasource/valid.ffm',
model_path='datasource/ffm_model.out',
overwrite_eva_path=True):
if (eva_df is None) ^ (eva_label is None):
raise Exception(
'params eva_df, eva_df must be all None or all have value.')
df.index = range(df.shape[0])
label.index = range(label.shape[0])
if self.model_type == 'lr':
self.clf = xl.create_ffm()
elif self.model_type == 'fm':
self.clf = xl.create_fm()
elif self.model_type == 'ffm':
self.clf = xl.create_linear()
else:
raise ValueError(self.model_type,
' is an invalid value for param cat.')
self.fe = FFMEncoder(df)
self.fe.fit(df, self.cutoff)
self.fe.transform(df, label, path)
if eva_df is not None:
eva_df.index = range(eva_df.shape[0])
eva_label.index = range(eva_label.shape[0])
self.fe.transform(eva_df, eva_label, eva_path)
self.clf.setTrain(path)
if eva_df is not None:
self.clf.setValidate(eva_path)
self.clf.fit(self.params, model_path)
self.model_path = model_path
def train(self):
# Training task
ffm_model = xl.create_ffm(
) # Use field-aware factorization machine (ffm)
ffm_model.setTrain("../data/movie_lens_100k/train.txt"
) # Set the path of training dataset
ffm_model.setValidate("../data/movie_lens_100k/test.txt"
) # Set the path of validation dataset
# Parameters:
# 0. task: binary classification
# 1. learning rate: 0.2
# 2. regular lambda: 0.002
# 3. evaluation metric: accuracy
param = {'task': 'binary', 'lr': 0.2, 'lambda': 0.002, 'metric': 'auc'}
# Start to train
# The trained model will be stored in model.out
if self.save_path != '':
ffm_model.fit(param, os.path.join(self.save_path, 'ffm.model'))
return ffm_model
def FFM():
ffm_model = xl.create_ffm()
ffm_model.setTrain("Train_ffm.txt")
ffm_model.setValidate("Test_ffm.txt")
# ffm_model.disableEarlyStop()
param = {
'task': 'binary', # ‘binary’ for classification, ‘reg’ for Regression
'k': 4, # Size of latent factor
'lr': 0.2, # Learning rate for GD
'opt': 'adagrad',
'lambda': 0.00002, # L2 Regularization Parameter
'metric': 'auc', # Metric for monitoring validation set performance
'epoch': 100, # Maximum number of Epochs
'nthread': 8,
'stop_window': 3
}
# ffm_model.setSigmoid()
ffm_model.fit(param, "model.out")
ffm_model.setTest("./Test_ffm.txt")
y_pred = ffm_model.predict("./model.out", "./output.txt")
return y_pred
def _FFM_train(df_all):
train_name, day7_name, cv_name, test_name = df_all
num = train_name.rsplit('_', 1)[-1]
ffm_model = xl.create_ffm()
ffm_model.setTrain(train_name)
ffm_model.setValidate(cv_name)
ffm_model.setTest(day7_name)
now_result = cache_pkl_path + 'FFM_day/model_day7_' + num
# ffm_model.disableEarlyStop()
#
param = {
'task': 'binary',
'lr': 0.1,
'lambda': 0.000005,
'epoch': 70,
'alpha': 0.1,
'lambda_1': 0.01
}
ffm_model.fit(param, "./model.out")
ffm_model.setSigmoid()
ffm_model.predict("./model.out", now_result)
predict_day7 = pd.read_csv(now_result, header=None)
predict_day7 = np.squeeze(predict_day7.values)
ffm_model.setTest(cv_name)
now_result = cache_pkl_path + 'FFM_day/model_cv__' + num
ffm_model.predict("./model.out", now_result)
predict_cv = pd.read_csv(now_result, header=None)
predict_cv = np.squeeze(predict_cv.values)
ffm_model.setTest(test_name)
now_result = cache_pkl_path + 'FFM_day/model_test__' + num
ffm_model.predict("./model.out", now_result)
predict_test = pd.read_csv(now_result, header=None)
predict_test = np.squeeze(predict_test.values)
return (predict_day7, predict_cv, predict_test)
def train():
ffm = xl.create_ffm()
train, test, _ = splitFFM()
ffm.setTrain(train)
ffm.setValidate(test)
model = './modelFFM'
sTime = time.strftime('%m%d-%H%M', time.localtime(time.time()))
if not os.path.exists(model): os.mkdir(model)
model = '%s/xlModel_%s.txt' % (model, sTime)
params = {
'epoch': 100,
'metric': 'auc',
'task': 'binary',
'k': 4,
'lr': 0.02,
'lambda': 1e-6,
'stop_window': 3,
}
ffm.fit(params, model)
def run_xlearn():
if MODEL == 'LM':
model = xl.create_linear()
elif MODEL == 'FM':
model = xl.create_fm()
else:
assert MODEL == 'FFM'
model = xl.create_ffm()
model.setTrain(TRAIN)
model.setValidate(TEST)
if WINDOW == 0:
model.disableEarlyStop()
param = {
'task': TASK,
'epoch': EPOCH,
'opt': OPT,
'metric': METRIC,
'k': K,
'lr': LEARNING_RATE,
'lambda': LAMBDA,
}
model.fit(param, './xlearn.model')
def train() :
# cf = file(sys.argv[1], "r")
# ct = file(sys.argv[4], "r")
model = xl.create_ffm()
param = {
'task':'reg',
'lr':0.1,
'lambda': 1,
'metric':'rmse',
'opt':'adagrad',
'k': 256,
'stop_window':1,
'init': 0.1,
'epoch':4
}
model.setTrain(sys.argv[2])
model.setValidate(sys.argv[3])
model.setTest(sys.argv[4])
model.disableNorm();
model.disableEarlyStop();
print param
model.fit(param, "./model.out")
model.predict("./model.out", "./xprediction.txt")
#! /usr/bin/python3
import xlearn as xl
root_path = '../../tencent_dataset/preliminary_contest_data/'
ffm_model = xl.create_ffm()
ffm_model.setTrain(root_path + 'train.ffm')
ffm_model.setValidate(root_path + 'valid.ffm')
param = {
'task': 'binary',
'lr': 0.1,
'lambda': 0.002,
'epoch': 20,
'metric': 'auc'
}
ffm_model.fit(param, root_path + 'ffm_model.out')
ffm_model.setTest(root_path + 'pred.ffm')
ffm_model.predict(root_path + 'ffm_model.out', root_path + 'output.txt')
'lambda': 0.002,
'epoch': 100,
'opt': 'adagrad'
}
## training
fm_model.fit(param, fp_model_fm)
## testing
fm_model.setTest(fp_test)
fm_model.setSigmoid()
fm_model.predict(fp_model_fm, fp_pred_fm)
##================ FFM ==================##
## training setting
ffm_model = xl.create_ffm() # Use field-aware factorization machine
ffm_model.setTrain(fp_train) # Training data
ffm_model.setValidate(fp_valid) # Validation data
ffm_model.setSigmoid()
param = {'task': 'binary',
'k': 20,
'lr': 0.02,
'lambda': 0.0001,
'epoch': 100,
'opt': 'adagrad'
}
## Train model
ffm_model.fit(param, fp_model_ffm)
