# deepfm paddle
import paddle
import paddle.nn as nn
import paddle.nn.functional as F
import math
class DeepFMLayer(nn.Layer):
def __init__(self, sparse_feature_number, sparse_feature_dim,
dense_feature_dim, sparse_num_field, layer_sizes):
super(DeepFMLayer, self).__init__()
self.sparse_feature_number = sparse_feature_number
self.sparse_feature_dim = sparse_feature_dim
self.dense_feature_dim = dense_feature_dim
self.sparse_num_field = sparse_num_field
self.layer_sizes = layer_sizes
self.fm = FM(sparse_feature_number, sparse_feature_dim,
dense_feature_dim, sparse_num_field)
self.dnn = DNN(sparse_feature_number, sparse_feature_dim,
dense_feature_dim, dense_feature_dim + sparse_num_field,
layer_sizes)
self.bias = paddle.create_parameter(
shape=[1],
dtype='float32',
default_initializer=paddle.nn.initializer.Constant(value=0.0))
def forward(self, sparse_inputs, dense_inputs):
y_first_order, y_second_order, feat_embeddings = self.fm.forward(
sparse_inputs, dense_inputs)
y_dnn = self.dnn.forward(feat_embeddings)
predict = F.sigmoid(y_first_order + y_second_order + y_dnn)
return predict
class FM(nn.Layer):
def __init__(self, sparse_feature_number, sparse_feature_dim,
dense_feature_dim, sparse_num_field):
super(FM, self).__init__()
self.sparse_feature_number = sparse_feature_number
self.sparse_feature_dim = sparse_feature_dim
self.dense_feature_dim = dense_feature_dim
self.dense_emb_dim = self.sparse_feature_dim
self.sparse_num_field = sparse_num_field
self.init_value_ = 0.1
use_sparse = True
if paddle.is_compiled_with_npu():
use_sparse = False
# sparse coding
self.embedding_one = paddle.nn.Embedding(
sparse_feature_number,
1,
padding_idx=0,
sparse=use_sparse,
weight_attr=paddle.ParamAttr(
initializer=paddle.nn.initializer.TruncatedNormal(
mean=0.0,
std=self.init_value_ /
math.sqrt(float(self.sparse_feature_dim)))))
self.embedding = paddle.nn.Embedding(
self.sparse_feature_number,
self.sparse_feature_dim,
sparse=use_sparse,
padding_idx=0,
weight_attr=paddle.ParamAttr(
initializer=paddle.nn.initializer.TruncatedNormal(
mean=0.0,
std=self.init_value_ /
math.sqrt(float(self.sparse_feature_dim)))))
# dense coding
self.dense_w_one = paddle.create_parameter(
shape=[self.dense_feature_dim],
dtype='float32',
default_initializer=paddle.nn.initializer.TruncatedNormal(
mean=0.0,
std=self.init_value_ /
math.sqrt(float(self.sparse_feature_dim))))
self.dense_w = paddle.create_parameter(
shape=[1, self.dense_feature_dim, self.dense_emb_dim],
dtype='float32',
default_initializer=paddle.nn.initializer.TruncatedNormal(
mean=0.0,
std=self.init_value_ /
math.sqrt(float(self.sparse_feature_dim))))
def forward(self, sparse_inputs, dense_inputs):
# -------------------- first order term --------------------
sparse_inputs_concat = paddle.concat(sparse_inputs, axis=1)
sparse_emb_one = self.embedding_one(sparse_inputs_concat)
dense_emb_one = paddle.multiply(dense_inputs, self.dense_w_one)
dense_emb_one = paddle.unsqueeze(dense_emb_one, axis=2)
y_first_order = paddle.sum(sparse_emb_one, 1) + paddle.sum(
dense_emb_one, 1)
# -------------------- second order term --------------------
sparse_embeddings = self.embedding(sparse_inputs_concat)
dense_inputs_re = paddle.unsqueeze(dense_inputs, axis=2)
dense_embeddings = paddle.multiply(dense_inputs_re, self.dense_w)
feat_embeddings = paddle.concat([sparse_embeddings, dense_embeddings],
1)
# sum_square part
summed_features_emb = paddle.sum(feat_embeddings,
1) # None * embedding_size
summed_features_emb_square = paddle.square(
summed_features_emb) # None * embedding_size
# square_sum part
squared_features_emb = paddle.square(
feat_embeddings) # None * num_field * embedding_size
squared_sum_features_emb = paddle.sum(squared_features_emb,
1) # None * embedding_size
y_second_order = 0.5 * paddle.sum(
summed_features_emb_square - squared_sum_features_emb,
1,
keepdim=True) # None * 1
return y_first_order, y_second_order, feat_embeddings
class DNN(paddle.nn.Layer):
def __init__(self, sparse_feature_number, sparse_feature_dim,
dense_feature_dim, num_field, layer_sizes):
super(DNN, self).__init__()
self.sparse_feature_number = sparse_feature_number
self.sparse_feature_dim = sparse_feature_dim
self.dense_feature_dim = dense_feature_dim
self.num_field = num_field
self.layer_sizes = layer_sizes
sizes = [sparse_feature_dim * num_field] + self.layer_sizes + [1]
acts = ["relu" for _ in range(len(self.layer_sizes))] + [None]
self._mlp_layers = []
for i in range(len(layer_sizes) + 1):
linear = paddle.nn.Linear(
in_features=sizes[i],
out_features=sizes[i + 1],
weight_attr=paddle.ParamAttr(
initializer=paddle.nn.initializer.Normal(
std=1.0 / math.sqrt(sizes[i]))))
self.add_sublayer('linear_%d' % i, linear)
self._mlp_layers.append(linear)
if acts[i] == 'relu':
act = paddle.nn.ReLU()
self.add_sublayer('act_%d' % i, act)
def forward(self, feat_embeddings):
y_dnn = paddle.reshape(feat_embeddings,
[-1, self.num_field * self.sparse_feature_dim])
for n_layer in self._mlp_layers:
y_dnn = n_layer(y_dnn)
return y_dnn
import paddle
from paddle.nn import Linear
import paddle.nn.functional as F
import numpy as np
import os
import random
class Regressor(paddle.nn.Layer):
# self代表类的实例自身
def __init__(self):
# 初始化父类中的一些参数
super(Regressor, self).__init__()
# 定义一层全连接层，输入维度是13，输出维度是1
self.fc = Linear(in_features=13, out_features=1)
# 网络的前向计算
def forward(self, inputs):
x = self.fc(inputs)
return x
# 声明定义好的线性回归模型
model = Regressor()
# 开启模型训练模式
model.train()
# 加载数据
training_data, test_data = load_data()
# 定义优化算法，使用随机梯度下降SGD
# 学习率设置为0.01
opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())
EPOCH_NUM = 10 # 设置外层循环次数
BATCH_SIZE = 10 # 设置batch大小
# 定义外层循环
for epoch_id in range(EPOCH_NUM):
# 在每轮迭代开始之前，将训练数据的顺序随机的打乱
np.random.shuffle(training_data)
# 将训练数据进行拆分，每个batch包含10条数据
mini_batches = [training_data[k:k+BATCH_SIZE] for k in range(0, len(training_data), BATCH_SIZE)]
# 定义内层循环
for iter_id, mini_batch in enumerate(mini_batches):
x = np.array(mini_batch[:, :-1]) # 获得当前批次训练数据
y = np.array(mini_batch[:, -1:]) # 获得当前批次训练标签（真实房价）
# 将numpy数据转为飞桨动态图tensor的格式
house_features = paddle.to_tensor(x)
prices = paddle.to_tensor(y)
# 前向计算
predicts = model(house_features)
# 计算损失
loss = F.square_error_cost(predicts, label=prices)
avg_loss = paddle.mean(loss)
if iter_id%20==0:
print("epoch: {}, iter: {}, loss is: {}".format(epoch_id, iter_id, avg_loss.numpy()))
# 反向传播，计算每层参数的梯度值
avg_loss.backward()
# 更新参数，根据设置好的学习率迭代一步
opt.step()
# 清空梯度变量，以备下一轮计算
opt.clear_grad()
# 保存模型参数，文件名为LR_model.pdparams
paddle.save(model.state_dict(), 'LR_model.pdparams')
print("模型保存成功，模型参数保存在LR_model.pdparams中")
# 参数为保存模型参数的文件地址
model_dict = paddle.load('LR_model.pdparams')
model.load_dict(model_dict)
model.eval()
# 参数为数据集的文件地址
one_data, label = load_one_example()
# 将数据转为动态图的variable格式
one_data = paddle.to_tensor(one_data)
predict = model(one_data)
# 对结果做反归一化处理
predict = predict * (max_values[-1] - min_values[-1]) + avg_values[-1]
# 对label数据做反归一化处理
label = label * (max_values[-1] - min_values[-1]) + avg_values[-1]
print("Inference result is {}, the corresponding label is {}".format(predict.numpy(), label))
