import pandas as pd
df=pd.read_csv("data/data178496/zhengqi_train.txt",sep='\t')
df.head()

df.isnull().sum()

V0        0
V1        0
V2        0
V3        0
V4        0
V5        0
V6        0
V7        0
V8        0
V9        0
V10       0
V11       0
V12       0
V13       0
V14       0
V15       0
V16       0
V17       0
V18       0
V19       0
V20       0
V21       0
V22       0
V23       0
V24       0
V25       0
V26       0
V27       0
V28       0
V29       0
V30       0
V31       0
V32       0
V33       0
V34       0
V35       0
V36       0
V37       0
target    0
dtype: int64

import pandas as pd
df_test=pd.read_csv("data/data178496/zhengqi_test.txt",sep='\t')

df_merge=df.append(df_test)

df_merge.head()

columns = df_merge.columns
print(columns)
for column in columns:
    col = df_merge[column]
    col_min = col.min()
    col_max = col.max()
    normalized = (col - col_min) / (col_max - col_min)
    df_merge[column] = normalized

Index(['V0', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6', 'V7', 'V8', 'V9', 'V10',       'V11', 'V12', 'V13', 'V14', 'V15', 'V16', 'V17', 'V18', 'V19', 'V20',       'V21', 'V22', 'V23', 'V24', 'V25', 'V26', 'V27', 'V28', 'V29', 'V30',       'V31', 'V32', 'V33', 'V34', 'V35', 'V36', 'V37', 'target'],
      dtype='object')

df_merge.dropna(axis=0,inplace=True)

df_merge.shape

(2888, 39)

df_merge.corr()

import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
sns.set_style('whitegrid')
# 热力图
plt.figure(figsize=(20,12))
sns.heatmap(df_merge.corr(), annot=True)

df=df_merge.iloc[:df.shape[0],:]
df_test=df_merge.iloc[df.shape[0]:,:]

df.shape

(2888, 39)

from sklearn.model_selection import train_test_split,cross_val_score
train,test=train_test_split(df,test_size=0.25,random_state=2023)

import paddle
import paddle.nn as nn
# 定义动态图
class Net(paddle.nn.Layer):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = paddle.nn.Linear(38, 1000)
        self.fc2 = paddle.nn.Linear(1000, 100)
        self.fc3 = paddle.nn.Linear(100, 50)
        self.fc4 = paddle.nn.Linear(50, 1)
    # 网络的前向计算函数
    def forward(self, inputs):
        y = self.fc1(inputs)
        y = self.fc2(y)
        y = self.fc3(y)
        pred = self.fc4(y)
        return pred

model=Net()
loss_func = paddle.nn.CrossEntropyLoss()
#优化器
opt = paddle.optimizer.Adam(learning_rate=0.1,parameters= model.parameters())

import paddle.nn.functional as F
EPOCH_NUM = 1000   # 设置外层循环次数
BATCH_SIZE = 256  # 设置batch大小
import numpy as np
# 定义外层循环
for epoch_id in range(EPOCH_NUM):
    # 在每轮迭代开始之前，将训练数据的顺序随机的打乱
    train.sample(frac=1)
    # 将训练数据进行拆分，每个batch包含10条数据
    mini_batches = [train[k:k+BATCH_SIZE] for k in range(0, len(train), BATCH_SIZE)]
    # 定义内层循环
    for iter_id, mini_batch in enumerate(mini_batches):
        x = np.array(mini_batch.iloc[:, :-1]) # 获得当前批次训练数据
        y = np.array(mini_batch.iloc[:, -1:])# 获得当前批次训练标签
        # 将numpy数据转为飞桨动态图tensor的格式
        features = paddle.to_tensor(x,dtype='float32')
        y = paddle.to_tensor(y,dtype='float32') 
        # 前向计算
        predicts = model(features)
        # 计算损失
        loss = F.square_error_cost(predicts, label=y)
        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中")

模型保存成功，模型参数保存在LR_model.pdparams中

target=df_merge['target']
target_max=target.max()
target_min=target.min()

# 参数为保存模型参数的文件地址
model_dict = paddle.load('LR_model.pdparams')
model.load_dict(model_dict)
model.eval()
# 参数为数据集的文件地址
one_data = np.array(test.iloc[:, :-1]) # 获得当前批次训练数据
label = np.array(test.iloc[:, -1:])# 获得当前批次训练标签
# 将数据转为动态图的variable格式 
one_data = paddle.to_tensor(one_data,dtype='float32')
predict = model(one_data)
predict=predict.numpy()

# 对结果做反归一化处理
predict = predict* (target_max - target_min) + target_min
# 对label数据做反归一化处理
label = label * (target_max - target_min) + target_min
for i in range(10):
    print("Inference result is {}, the corresponding label is {}".format(predict[i], label[i]))

Inference result is [0.18284929], the corresponding label is [0.12307417]
Inference result is [0.3642674], the corresponding label is [0.46524543]
Inference result is [0.382918], the corresponding label is [0.46291652]
Inference result is [0.50540245], the corresponding label is [0.52185597]
Inference result is [0.63235503], the corresponding label is [0.62683626]
Inference result is [0.6009079], the corresponding label is [0.59620208]
Inference result is [0.6699288], the corresponding label is [0.74435686]
Inference result is [0.51734024], the corresponding label is [0.55499821]
Inference result is [0.4891268], the corresponding label is [0.59638123]
Inference result is [0.40018553], the corresponding label is [0.49390899]