def build(self, task): assert task in ['regression', 'binary'] if self.model_architecture == "DeepFM": self.model = DeepFM( self.data.linear_feature_columns, self.data.dnn_feature_columns, task=task, ) else: raise NotImplementedError( 'At the current stage of the development, only a DeepFM is supported' ) task_attr = { 'regression': { 'loss': 'mse', 'metrics': 'mse' }, 'binary': { 'loss': 'binary_crossentropy', 'metrics': 'accuracy' } } if task == "regression": loss = "mse" metrics = "mse" elif task == "binary": loss = "binary_crossentropy" metrics = "accuracy" self.model.compile(optimizer="adam", loss=task_attr[task]['loss'], metrics=task_attr[task]['metrics'])
def test_DeepFM(use_fm, hidden_size, sparse_feature_num): model_name = "DeepFM" sample_size = 64 feature_dim_dict = {"sparse": {}, 'dense': []} for name, num in zip(["sparse", "dense"], [sparse_feature_num, sparse_feature_num]): if name == "sparse": for i in range(num): feature_dim_dict[name][name + '_' + str(i)] = np.random.randint(1, 10) else: for i in range(num): feature_dim_dict[name].append(name + '_' + str(i)) sparse_input = [np.random.randint(0, dim, sample_size) for dim in feature_dim_dict['sparse'].values()] dense_input = [np.random.random(sample_size) for name in feature_dim_dict['dense']] y = np.random.randint(0, 2, sample_size) x = sparse_input + dense_input model = DeepFM(feature_dim_dict, use_fm=use_fm, hidden_size=hidden_size, keep_prob=0.5, ) model.compile('adam', 'binary_crossentropy', metrics=['binary_crossentropy']) model.fit(x, y, batch_size=100, epochs=1, validation_split=0.5) print(model_name+" test train valid pass!") model.save_weights(model_name + '_weights.h5') model.load_weights(model_name + '_weights.h5') print(model_name+" test save load weight pass!") save_model(model, model_name + '.h5') model = load_model(model_name + '.h5', custom_objects) print(model_name + " test save load model pass!") print(model_name + " test pass!")
def model_gridsearch(lfc,dfc,grid): model_names = [] models = [] if grid == 'embedding_size': # embedding_size = [2, 4, 6, 8, 10, 15, 20, 25, 30, 40, 50, 60, 80, 100, 120, 160, 200] embedding_size = [ 25, 30, 40, 50] xlabel = embedding_size elif grid == 'dnn_hidden_units': # dnn_hidden_units = [4, 5, 6, 7, 8, 9, 10] dnn_hidden_units = [ 7,8, 9,10] xlabel = dnn_hidden_units elif grid == 'dnn_hidden_units_len': # dnn_hidden_units_len = [2, 3, 4, 5, 6, 7, 8] dnn_hidden_units_len = [2, 3,4,5] xlabel = dnn_hidden_units_len elif grid == 'dnn_dropout': # dnn_dropout = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8] dnn_dropout = [0, 0.1, 0.2,0.3] xlabel= dnn_dropout else: models = [DeepFM(lfc, dfc, task='binary')] model_names = ['DeepFM'] xlabel = [] return (models, model_names,xlabel) for a in xlabel: # dnn_hidden_units dnn_dropout embedding_size if grid == 'embedding_size': models.append(DeepFM(lfc, dfc, embedding_size=a, task='binary', seed=1024) ) elif grid == 'dnn_hidden_units': models.append(DeepFM(lfc, dfc, dnn_hidden_units=(2**a, 2**a), task='binary', seed=1024) ) elif grid == 'dnn_hidden_units_len': models.append(DeepFM(lfc, dfc, dnn_hidden_units = (128,) * a, task='binary', seed=1024) ) elif grid == 'dnn_dropout': models.append(DeepFM(lfc, dfc, dnn_dropout= a, task='binary', seed=1024) ) model_names.append(str(a) + ' '+ grid) return (models, model_names,xlabel) ''' models = [#xDeepFM(linear_feature_columns, dnn_feature_columns, task='binary'), DeepFM(linear_feature_columns, dnn_feature_columns, embedding_size=8,task='binary'), # linear_feature_columns, dnn_feature_columns, embedding_size=8, use_fm=True, dnn_hidden_units=(128, 128), # l2_reg_linear=0.00001, l2_reg_embedding=0.00001, l2_reg_dnn=0, init_std=0.0001, seed=1024, dnn_dropout=0, # dnn_activation='relu', dnn_use_bn=False, task='binary' #CCPM(linear_feature_columns, dnn_feature_columns, task='binary'), #FNN(linear_feature_columns, dnn_feature_columns, task='binary'), #PNN(dnn_feature_columns, task='binary'), #WDL(linear_feature_columns, dnn_feature_columns, task='binary'), #NFM(linear_feature_columns, dnn_feature_columns, task='binary'), #AFM(linear_feature_columns, dnn_feature_columns, task='binary'), #DCN(dnn_feature_columns, task='binary'), #AutoInt(dnn_feature_columns, task='binary'), #NFFM(linear_feature_columns, dnn_feature_columns, task='binary'), #FGCNN(dnn_feature_columns, task='binary'), #FiBiNET(linear_feature_columns, dnn_feature_columns, task='binary') ] ''' '''
def main(dataPath, dataPath_val, batch_size): # must have list of training files files = glob.glob(dataPath + "/*.csv")[::5] # validation files files_val = glob.glob(dataPath_val + "/*.csv")[::5] # Count number of examples in training data nexs = get_total_examples(files) print("Number of training examples: ", nexs) nexs_val = get_total_examples(files_val) print("Number of validation examples: ", nexs_val) # Create data generator train_gen = DataGenerator(files, nexs, batch_size=batch_size) val_gen = DataGenerator(files_val, nexs_val, batch_size=batch_size) linear_feature_columns = train_gen.linear_feature_columns dnn_feature_columns = train_gen.dnn_feature_columns # 4.Define Model,train,predict and evaluate model = DeepFM(linear_feature_columns, dnn_feature_columns, task='binary') optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, decay=0.0) model.compile( optimizer, "binary_crossentropy", metrics=['binary_crossentropy', auroc], ) pbar = ProgbarLogger(count_mode='steps', stateful_metrics=None) weights_file = "model-5-lr0p001.h5" model_checkpoint = ModelCheckpoint(weights_file, monitor="val_binary_crossentropy", save_best_only=True, save_weights_only=True, verbose=1) history = model.fit_generator(train_gen, epochs=10, verbose=1, steps_per_epoch=nexs / batch_size, validation_data=val_gen, validation_steps=nexs / batch_size, callbacks=[model_checkpoint])
def fit(self, X, y): X_ = X.copy() self.dense_features = list(X_.columns.difference(self.cat_features)) logger.debug("MinMaxScaler") self.min_max_scaler.fit(X_[self.dense_features]) X_[self.dense_features] = self.min_max_scaler.transform( X_[self.dense_features]) self._column_mapping(X_) X_.columns = [self.columns_mapping[col] for col in X_.columns] self.fixlen_feature_columns = [ SparseFeat( self.columns_mapping[feat], vocabulary_size=X_[self.columns_mapping[feat]].max() + 1, embedding_dim=4, ) for i, feat in enumerate(self.cat_features) ] + [ DenseFeat( self.columns_mapping[feat], 1, ) for feat in self.dense_features ] self.feature_names = get_feature_names(self.fixlen_feature_columns) logger.debug("Compile DeepFM model") self.model = DeepFM(self.fixlen_feature_columns, self.fixlen_feature_columns, task="binary") self.model.compile( "adam", "binary_crossentropy", metrics=["binary_crossentropy"], ) logger.debug("Fit DeepFM") train_model_input = { name: X_[name].values for name in self.feature_names } self.model.fit( train_model_input, y, batch_size=256, epochs=3, verbose=2, validation_split=0.2, )
def model_generate(train_X, train_y, val_X, val_y, linear_feature_columns, dnn_feature_columns): model = DeepFM(linear_feature_columns, dnn_feature_columns, embedding_size=32) model.compile("adam", "binary_crossentropy", metrics=[roc_auc_score_pyfunc, log_loss_pyfunc]) history = model.fit(train_X, train_y, validation_data=(val_X, val_y), batch_size=4096, epochs=5, callbacks=[EarlyStopping()]) return model, history
def test_DeepFM(use_fm, hidden_size, sparse_feature_num): model_name = "DeepFM" sample_size = 64 feature_dim_dict = {"sparse": {}, 'dense': []} for name, num in zip(["sparse", "dense"], [sparse_feature_num, sparse_feature_num]): if name == "sparse": for i in range(num): feature_dim_dict[name][name + '_' + str(i)] = np.random.randint(1, 10) else: for i in range(num): feature_dim_dict[name].append(name + '_' + str(i)) sparse_input = [ np.random.randint(0, dim, sample_size) for dim in feature_dim_dict['sparse'].values() ] dense_input = [ np.random.random(sample_size) for name in feature_dim_dict['dense'] ] y = np.random.randint(0, 2, sample_size) x = sparse_input + dense_input model = DeepFM( feature_dim_dict, use_fm=use_fm, hidden_size=hidden_size, keep_prob=0.5, ) check_model(model, model_name, x, y)
def update_params(self, recompile=True, **kwargs): ''' Update parameters for the recommender and re-compile the DeepFM model unless recompile is set to False. Example ------- deepnn.update_params(epochs=20, deepfm__l2_reg_linear=2e-4) ''' for (k, v) in kwargs.items(): if(k in self.params): self.params[k] = v else: raise ValueError('{0} is not a valid parameter for RecommenderDeepNN.'.format(k)) self._set_params_deepfm() if(recompile == True and self.model is not None): self.model = DeepFM(self.features_linear, self.features_dnn, task='regression', **self.params_deepfm)
def run_deepfm_model(): train, test, train_model_input, test_model_input, dnn_feature_columns, linear_feature_columns, feature_names, target = read_data_as_model( ) #Define Model,train,predict and evaluate model = DeepFM(linear_feature_columns, dnn_feature_columns, task='binary') model.compile( "adam", "binary_crossentropy", metrics=['binary_crossentropy'], ) model.fit( train_model_input, train[target].values, batch_size=256, epochs=10, verbose=2, validation_split=0.2, ) pred_ans = model.predict(test_model_input, batch_size=256) print("test LogLoss", round(log_loss(test[target].values, pred_ans), 4)) print("test AUC", round(roc_auc_score(test[target].values, pred_ans), 4)) return pred_ans, test[target].values, round( roc_auc_score(test[target].values, pred_ans), 4), 'deepfm'
def test_DeepFM(hidden_size, sparse_feature_num): model_name = "DeepFM" sample_size = SAMPLE_SIZE x, y, feature_columns = get_test_data(sample_size, sparse_feature_num=sparse_feature_num, dense_feature_num=sparse_feature_num) model = DeepFM(feature_columns, feature_columns, dnn_hidden_units=hidden_size, dnn_dropout=0.5) check_model(model, model_name, x, y)
def load_model(self): with open("data/DeepFM_data.pkl", "rb") as f_in: ( self.columns_mapping, self.min_max_scaler, self.dense_features, self.fixlen_feature_columns, self.feature_names, ) = pickle.load(f_in) self.model = DeepFM(self.fixlen_feature_columns, self.fixlen_feature_columns, task="binary") self.model.compile( "adam", "binary_crossentropy", metrics=["binary_crossentropy"], ) self.model.load_weights("data/DeepFM_w.h5")
def _build_model(self): to_drop = config.Keywords_Categories[self.params['category']] self._build_category_dict(drop_categories=to_drop) attrs_matrix, attrs_max_len = self._get_category_matrix(self.data) vars_fixlen = [SparseFeat(var, self.data[var].nunique(), embedding_dim=4) for var in self.features_sparse] vars_fixlen += [DenseFeat(var, 1,) for var in self.features_dense] vars_varlen = [VarLenSparseFeat(SparseFeat('categories', vocabulary_size=len(self.attr2index) + 1, embedding_dim=4), maxlen=attrs_max_len, combiner='mean', weight_name='attrs_weight' if self.params['weight'] else None)] self.features_linear = vars_fixlen + vars_varlen self.features_dnn = vars_fixlen + vars_varlen self.model = DeepFM(self.features_linear, self.features_dnn, task='regression', **self.params_deepfm) return attrs_matrix, attrs_max_len
def test_long_dense_vector(): #构造特征 feature_columns = [ SparseFeat( 'user_id', 4, ), SparseFeat( 'item_id', 5, ), DenseFeat("pic_vec", 5) ] fixlen_feature_names = get_feature_names(feature_columns) #构造样本 user_id = np.array([[1], [0], [1]]) item_id = np.array([[3], [2], [1]]) pic_vec = np.array([[0.1, 0.5, 0.4, 0.3, 0.2], [0.1, 0.5, 0.4, 0.3, 0.2], [0.1, 0.5, 0.4, 0.3, 0.2]]) label = np.array([1, 0, 1]) input_dict = {'user_id': user_id, 'item_id': item_id, 'pic_vec': pic_vec} model_input = [input_dict[name] for name in fixlen_feature_names] #创建模型model model = DeepFM(feature_columns, feature_columns[:-1]) # model.summary() #tf.keras.utils.plot_model(model, "test_compu") #训练模型 model.compile('adagrad', 'binary_crossentropy') model.fit(model_input, label)
def test_DeepFM(use_fm, hidden_size): name = "DeepFM" sample_size = 64 feature_dim_dict = { 'sparse': { 'sparse_1': 2, 'sparse_2': 5, 'sparse_3': 10 }, 'dense': ['dense_1', 'dense_2', 'dense_3'] } sparse_input = [ np.random.randint(0, dim, sample_size) for dim in feature_dim_dict['sparse'].values() ] dense_input = [ np.random.random(sample_size) for name in feature_dim_dict['dense'] ] y = np.random.randint(0, 2, sample_size) x = sparse_input + dense_input model = DeepFM( feature_dim_dict, use_fm=use_fm, hidden_size=hidden_size, keep_prob=0.5, ) model.compile('adam', 'binary_crossentropy', metrics=['binary_crossentropy']) model.fit(x, y, batch_size=100, epochs=1, validation_split=0.5) print(name + " test train valid pass!") model.save_weights(name + '_weights.h5') model.load_weights(name + '_weights.h5') print(name + " test save load weight pass!") save_model(model, name + '.h5') model = load_model(name + '.h5', custom_objects) print(name + " test save load model pass!") print(name + " test pass!")
def test_long_dense_vector(): feature_columns = [ SparseFeat( 'user_id', 4, ), SparseFeat( 'item_id', 5, ), DenseFeat("pic_vec", 5) ] fixlen_feature_names = get_feature_names(feature_columns) user_id = np.array([[1], [0], [1]]) item_id = np.array([[3], [2], [1]]) pic_vec = np.array([[0.1, 0.5, 0.4, 0.3, 0.2], [0.1, 0.5, 0.4, 0.3, 0.2], [0.1, 0.5, 0.4, 0.3, 0.2]]) label = np.array([1, 0, 1]) input_dict = {'user_id': user_id, 'item_id': item_id, 'pic_vec': pic_vec} model_input = [input_dict[name] for name in fixlen_feature_names] model = DeepFM(feature_columns, feature_columns[:-1]) model.compile('adagrad', 'binary_crossentropy') model.fit(model_input, label)
def train_deepFM(): k = featureengineer.k #缺失值填充+编码处理 data,appsnum, tags_nums = trainmodel.data,trainmodel.appsnum,trainmodel.tags_nums data[trainmodel.sparse_features] = data[trainmodel.sparse_features].fillna('-1', ) for feat in trainmodel.dense_features: data[feat].fillna(data[feat].dropna().mean(), inplace=True) for feat in trainmodel.sparse_features: data[feat] = data[feat].apply(lambda x:str(x)) lbe = LabelEncoder() data[feat] = lbe.fit_transform(data[feat]) mms = MinMaxScaler(feature_range=(0, 1)) data[trainmodel.dense_features] = mms.fit_transform(data[trainmodel.dense_features]) #数据格式转换 fixlen_feature_columns = [SparseFeat(feat, vocabulary_size=data[feat].max()+1, embedding_dim=8) for i, feat in enumerate(trainmodel.sparse_features)] + \ [DenseFeat(feat, 1, ) for feat in trainmodel.dense_features] lgbOut_feature_columns = [SparseFeat(feat, vocabulary_size=data[feat].max()+1, embedding_dim=1) for i, feat in enumerate(trainmodel.lgbOut_Features)] key2index_len = {'applist': appsnum+1, 'new_tag': tags_nums} varlen_features = [VarLenSparseFeat('%s' % i, vocabulary_size=key2index_len[i], maxlen=k, embedding_dim=8, combiner='mean',weight_name=None) for i in trainmodel.var_features] dnn_feature_columns = fixlen_feature_columns + varlen_features linear_feature_columns = fixlen_feature_columns + varlen_features + lgbOut_feature_columns feature_names = get_feature_names(linear_feature_columns + dnn_feature_columns) sparse_dense_features = trainmodel.sparse_features + trainmodel.dense_features + trainmodel.lgbOut_Features train, test = train_test_split(data, test_size=0.2) train_model_input = {name: train[name] for name in sparse_dense_features} test_model_input = {name: test[name] for name in sparse_dense_features} for x in trainmodel.var_features: if x == 'applist': train_model_input[x] = np.array(train[x].tolist()) test_model_input[x] = np.array(test[x].tolist()) if x == 'new_tag': train_model_input[x] = np.array(train[x].tolist())-appsnum test_model_input[x] = np.array(test[x].tolist())-appsnum # 模型 model = DeepFM(linear_feature_columns=linear_feature_columns, dnn_feature_columns=dnn_feature_columns, dnn_hidden_units=(50, 30, 30), l2_reg_linear=0.001, l2_reg_embedding=0.001, l2_reg_dnn=0, init_std=0.0001, seed=1024, dnn_dropout=0.1, dnn_activation='relu', dnn_use_bn=True, task='binary') model.compile("adam", "binary_crossentropy",metrics=['AUC'], ) history = model.fit(train_model_input, train['target'].values, batch_size=256, epochs=1, verbose=2, validation_split=0.2, ) pred_ans = model.predict(test_model_input, batch_size=256) print("test AUC", round(roc_auc_score(test['target'].values, pred_ans), 4))
def test_DeepFM(use_fm, hidden_size, sparse_feature_num): model_name = "DeepFM" sample_size = SAMPLE_SIZE x, y, feature_dim_dict = get_test_data(sample_size, sparse_feature_num, sparse_feature_num) model = DeepFM( feature_dim_dict, use_fm=use_fm, hidden_size=hidden_size, keep_prob=0.5, ) check_model(model, model_name, x, y)
def train_model(train, test, linear_feature, dnn_feature): model = DeepFM(linear_feature, dnn_feature, task='binary') model.compile( "adam", "binary_crossentropy", metrics=['AUC'], ) history = model.fit( *train, batch_size=512, epochs=5, verbose=2, validation_split=0.1, ) pred_ans = model.predict(test[0], batch_size=512) print("test LogLoss", round(log_loss(test[1], pred_ans), 4)) print("test AUC", round(roc_auc_score(test[1], pred_ans), 4))
def deepfm_model(linear_feature_columns, dnn_feature_columns, train_model_input, train, test_model_input, test): cols = ['model', 'RMSE', 'MAE', 'MSE', 'AUC', 'score'] df_result = pd.DataFrame(columns=cols, index=range(1)) model = DeepFM(linear_feature_columns, dnn_feature_columns, dnn_hidden_units=config.deepfm_att["dnn_hidden_units"], init_std=config.deepfm_att["init_std"], seed=config.deepfm_att["seed"], dnn_dropout=config.deepfm_att["dnn_dropout"], dnn_activation=config.deepfm_att["dnn_activation"], task=config.deepfm_att["task"], fm_group=config.deepfm_att["fm_group"], dnn_use_bn=config.deepfm_att["dnn_use_bn"]) model.compile("adam", "mse", metrics=['mse']) history = model.fit(train_model_input, train[target].values, batch_size=256, epochs=config.model_epoch['epoch'], verbose=2, validation_split=0.2) pred_ans = model.predict(test_model_input, batch_size=256) save_model(model, 'saved_deepfm.h5') # save_model auc = roc_auc_score(test[target].values, pred_ans) df_result.loc[0].model = "DeepFM" df_result.loc[0].RMSE = np.round( math.sqrt(mean_squared_error(test[target].values, pred_ans)), 3) df_result.loc[0].MAE = np.round( mean_absolute_error(test[target].values, pred_ans), 3) df_result.loc[0].MSE = np.round( mean_squared_error(test[target].values, pred_ans), 3) df_result.loc[0].AUC = np.round(auc, 3) #df_result.loc[0].score=(1/df_result.iloc[0]['RMSE'])*(1/df_result.iloc[0]['MAE'])*(2*df_result.iloc[0]['AUC']) return df_result
del varlen_list['%s_%s' % (i, j)] # 4.Define Model, train, predict and evaluate checkpoint_path = path_model + "cp.ckpt" checkpoint_dir = os.path.dirname(checkpoint_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path, save_weights_only=True, verbose=1) # 编译有错,临时去掉embedding_size=8,use_fm=True,编译不过 model = DeepFM(linear_feature_columns, dnn_feature_columns, fm_group=fixlen_feature_columns, dnn_hidden_units=(256, 256, 256), l2_reg_linear=0.001, l2_reg_embedding=0.001, l2_reg_dnn=0, init_std=0.0001, seed=1024, dnn_dropout=0.5, dnn_activation='relu', dnn_use_bn=True, task='binary') try: model.load_weights(checkpoint_path) print('load weights') except: pass model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['accuracy', 'AUC']) history = model.fit(train_model_input,
sparse_feature_dim = {feat: data[feat].nunique() for feat in sparse_features} sequence_feature = [VarLenFeature('genres', len(key2index), max_len, 'mean')] # 3.generate input data for model sparse_input = [data[feat].values for feat in sparse_feature_dim] dense_input = [] sequence_input = [genres_list] sequence_length_input = [genres_length] model_input = sparse_input + dense_input + sequence_input + \ sequence_length_input # make sure the order is right # 4.Define Model,compile and train model = DeepFM( { "sparse": sparse_feature_dim, "dense": [], "sequence": sequence_feature }, final_activation='linear') model.compile( "adam", "mse", metrics=['mse'], ) history = model.fit( model_input, data[target].values, batch_size=256, epochs=10, verbose=2,
# 1.Label Encoding for sparse features,and do simple Transformation for dense features for feat in sparse_features: lbe = LabelEncoder() data[feat] = lbe.fit_transform(data[feat]) # 2.count #unique features for each sparse field sparse_feat_list = [ SingleFeat(feat, data[feat].nunique()) for feat in sparse_features ] # 3.generate input data for model train, test = train_test_split(data, test_size=0.2) train_model_input = [train[feat.name].values for feat in sparse_feat_list] test_model_input = [test[feat.name].values for feat in sparse_feat_list] # 4.Define Model,train,predict and evaluate model = DeepFM({"sparse": sparse_feat_list}, task='regression') model.compile( "adam", "mse", metrics=['mse'], ) history = model.fit( train_model_input, train[target].values, batch_size=256, epochs=10, verbose=2, validation_split=0.2, ) pred_ans = model.predict(test_model_input, batch_size=256)
'TitleID', 'DescriptionID', 'Gender', 'Age'] target = ['CTR'] # 1.Label Encoding for sparse features,and do simple Transformation for dense features for feat in sparse_features: lbe = LabelEncoder() data[feat] = lbe.fit_transform(data[feat]) # 2.count #unique features for each sparse field sparse_feature_dim = {feat: data[feat].nunique() for feat in sparse_features} # 3.generate input data for model model_input = [data[feat].values for feat in sparse_feature_dim] if mode == 'train': # 4.Define Model,compile and train model = DeepFM({"sparse": sparse_feature_dim, "dense": []}, final_activation='sigmoid') model.compile("adam", "binary_crossentropy", metrics=['binary_crossentropy']) filepath = 'model_save/deep_fm_sample-ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5' checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min') history = model.fit(model_input, data[target].values, callbacks=[checkpoint], batch_size=batch_size, epochs=50, verbose=1, validation_split=0.2,) elif mode == 'test': model = DeepFM({"sparse": sparse_feature_dim, "dense": []}, final_activation='sigmoid') model.load_weights('model_save/deep_fm_sample-ep001-loss0.184-val_loss0.172.h5') # model = load_model('model_save/deep_fm_sample-ep001-loss0.192-val_loss0.176.h5')
# 1.Use hashing encoding on the fly for sparse features,and process sequence features genres_list = list(map(lambda x: x.split('|'), data['genres'].values)) genres_length = np.array(list(map(len, genres_list))) max_len = max(genres_length) # Notice : padding=`post` genres_list = pad_sequences(genres_list, maxlen=max_len, padding='post', dtype=object, value=0).astype(str) # 2.set hashing space for each sparse field and generate feature config for sequence feature fixlen_feature_columns = [SparseFeat(feat, data[feat].nunique() * 5, embedding_dim=4, use_hash=True, dtype='string') for feat in sparse_features] varlen_feature_columns = [ VarLenSparseFeat(SparseFeat('genres', vocabulary_size=100, embedding_dim=4, use_hash=True, dtype="string"), maxlen=max_len, combiner='mean', )] # Notice : value 0 is for padding for sequence input feature linear_feature_columns = fixlen_feature_columns + varlen_feature_columns dnn_feature_columns = fixlen_feature_columns + varlen_feature_columns feature_names = get_feature_names(linear_feature_columns + dnn_feature_columns) # 3.generate input data for model model_input = {name: data[name] for name in feature_names} model_input['genres'] = genres_list # 4.Define Model,compile and train model = DeepFM(linear_feature_columns, dnn_feature_columns, task='regression') model.compile("adam", "mse", metrics=['mse'], ) history = model.fit(model_input, data[target].values, batch_size=256, epochs=10, verbose=2, validation_split=0.2, )
# 2.count #unique features for each sparse field sparse_feature_dim = {} with open('./data/features_infos_combined.txt') as fr: # with open('./data/sample/features_infos.txt') as fr: for line in fr: records = line.strip().split(':') if records[0] in exclude: continue sparse_feature_dim[records[0]] = int(records[1]) fr.close() # 4.Define Model,compile and train model = DeepFM({ "sparse": sparse_feature_dim, "dense": [] }, embedding_size=embedding_size, hidden_size=hidden_size, final_activation='sigmoid') if mode == 'train': model.compile("adam", "binary_crossentropy", metrics=['binary_crossentropy']) filepath = 'model_save/deep_fm_fn-ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}-bs' + str(batch_size)\ + '-ee' + str(embedding_size) + '-hz' + str(hidden_size) + '.h5' checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1,
SingleFeat(feat, data[feat].nunique()) for feat in sparse_features ] dense_feature_list = [SingleFeat(feat, 0) for feat in dense_features] # 3.generate input data for model train, test = train_test_split(data, test_size=0.2) train_model_input = [train[feat.name].values for feat in sparse_feature_list] + \ [train[feat.name].values for feat in dense_feature_list] test_model_input = [test[feat.name].values for feat in sparse_feature_list] + \ [test[feat.name].values for feat in dense_feature_list] # 4.Define Model,train,predict and evaluate model = DeepFM({ "sparse": sparse_feature_list, "dense": dense_feature_list }, final_activation='sigmoid') model.compile( "adam", "binary_crossentropy", metrics=['binary_crossentropy'], ) history = model.fit( train_model_input, train[target].values, batch_size=256, epochs=10, verbose=2, validation_split=0.2,
N_FOLDS = 5 CV_SEED = 0 # In[ ]: # train_and_val_model_input = {name: x_train_val[name] for name in feature_names} with tf.device("/cpu:0"): # model = DeepFM(linear_feature_columns=linear_feature_columns, # dnn_feature_columns=dnn_feature_columns, # dnn_dropout=0.1, # dnn_hidden_units=(512, 128), # task='binary') model = DeepFM( linear_feature_columns, dnn_feature_columns, task='binary', dnn_dropout=0.1, dnn_hidden_units=(512, 128), ) model = multi_gpu_model(model, NUM_WORKERS) model.compile( optimizer=tf.keras.optimizers.Adam(3e-4), # loss="binary_crossentropy", loss=multi_category_focal_loss2(alpha=0.1), metrics=[auroc], ) dirpath = Path('checkpoint') if dirpath.exists() and dirpath.is_dir(): shutil.rmtree(dirpath) os.mkdir('checkpoint')
data[feature] = lbe.fit_transform(data[feature]) # 计算每个特征中的 不同特征值的个数 fixlen_feature_columns = [ SparseFeat(feature, data[feature].nunique()) for feature in sparse_features ] linear_feature_columns = fixlen_feature_columns dnn_feature_columns = fixlen_feature_columns feature_names = get_feature_names(linear_feature_columns + dnn_feature_columns) # 将数据集切分成训练集和测试集 train, test = train_test_split(data, test_size=0.2) train_model_input = {name: train[name].values for name in feature_names} test_model_input = {name: test[name].values for name in feature_names} # 使用DeepFM进行训练 model = DeepFM(linear_feature_columns, dnn_feature_columns, task='regression') model.compile( "adam", "mse", metrics=['mse'], ) history = model.fit( train_model_input, train[target].values, batch_size=256, epochs=1, verbose=True, validation_split=0.2, ) # 使用DeepFM进行预测 pred_ans = model.predict(test_model_input, batch_size=256)
dtype=tf.int64, embedding_dim = embedding_size) for feat in sparse_f] varlen_feature_columns = [VarLenSparseFeat(SparseFeat(vfeat, vocabulary_size = varlen_vcab_dic[vfeat] + 1, dtype=tf.int64, embedding_dim = embedding_size), maxlen = varlen_maxlen_f[vfeat]) for vfeat in varlen_f] # %% linear_feature_columns, dnn_feature_columns = \ sparse_feature_columns + varlen_feature_columns, sparse_feature_columns + varlen_feature_columns # %% model = DeepFM(linear_feature_columns, dnn_feature_columns, dnn_hidden_units=NNconfig_dic["dnn_hidden_units"], l2_reg_dnn=NNconfig_dic["l2_reg_dnn"], l2_reg_embedding=NNconfig_dic["l2_reg_embedding"], l2_reg_linear=NNconfig_dic["l2_reg_linear"], dnn_dropout=NNconfig_dic["dnn_dropout"], dnn_use_bn=NNconfig_dic["dnn_use_bn"], dnn_activation=NNconfig_dic["dnn_activation"]) NNconfig_dic["model_name"] = "DeepFM" # %% opt = tf.keras.optimizers.Adam(learning_rate=NNconfig_dic["lr"]) NNconfig_dic["optimizer"] = "Adam" # %% model.compile(optimizer=opt, loss=tf.losses.BinaryCrossentropy(), metrics=[tf.keras.metrics.AUC()])
dnn_feature_columns = fixlen_feature_columns linear_feature_columns = fixlen_feature_columns feature_names = get_feature_names(linear_feature_columns + dnn_feature_columns) # 3.generate input data for model train, test = train_test_split(data, test_size=0.2) train_model_input = {name: train[name] for name in feature_names} test_model_input = {name: test[name] for name in feature_names} # 4.Define Model,train,predict and evaluate model = DeepFM(linear_feature_columns, dnn_feature_columns, task='binary') model = multi_gpu_model(model, gpus=2) model.compile( "adam", "binary_crossentropy", metrics=['binary_crossentropy'], ) history = model.fit( train_model_input, train[target].values, batch_size=256, epochs=10, verbose=2, validation_split=0.2,
from deepctr.models import DeepFM if __name__ == "__main__": data = pd.read_csv("./movielens_sample.txt") sparse_features = ["movie_id", "user_id", "gender", "age", "occupation", "zip"] target = ['rating'] # 1.Label Encoding for sparse features,and do simple Transformation for dense features for feat in sparse_features: lbe = LabelEncoder() data[feat] = lbe.fit_transform(data[feat]) # 2.count #unique features for each sparse field sparse_feature_dim = {feat: data[feat].nunique() for feat in sparse_features} # 3.generate input data for model train, test = train_test_split(data, test_size=0.2) train_model_input = [train[feat].values for feat in sparse_feature_dim] test_model_input = [test[feat].values for feat in sparse_feature_dim] # 4.Define Model,train,predict and evaluate model = DeepFM({"sparse": sparse_feature_dim, "dense": []}, final_activation='linear') model.compile("adam", "mse", metrics=['mse'],) history = model.fit(train_model_input, train[target].values, batch_size=256, epochs=1, verbose=2, validation_split=0.2,) pred_ans = model.predict(test_model_input, batch_size=256) print("test MSE", round(mean_squared_error( test[target].values, pred_ans), 4))