如何使用Tensorflow建立神经网络并且预测_tensorflow预测新数据

---

前言

我总结的建立神经网络的具体步骤，和一些细节，以及提供案例仅供参考

---

一、配置环境

• python3.8版本
• Tensorflow 2.12版本
• keras 2.11版本

二、训练模型步骤（Train_model.py）

1.导入数据集，第三方库，编写实用函数

• 数据集
  

• 需要预测的特征

• 

• 导入数据集，将特征和目标分开存放

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import tensorflow as tf
from keras import Sequential
from keras.layers import Dense
import pickle

def load_x(filename):
    X = np.loadtxt(filename, delimiter=',')
    return X

def load_y(filename):
    y = np.loadtxt(filename, delimiter=',')
    return y


def eval_mse(y, yhat):
    m = len(y)
    err = (yhat - y) ** 2
    err = np.sum(err)
    err = err / (2 * m)
    return (err)

X = load_x("dataX.txt")
y = load_y("datay.txt")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.数据归一化

• 当你的数据集里面的值相差过大的时候，可以进行归一化，这样训练模型的速度会更快
• 如果数据集的size很小，可以进行复制，增大size，减少训练次数

Xs = StandardScaler()
Xn = Xs.fit_transform(X)
X_new = np.tile(Xn, (20000, 1))
ys = StandardScaler()
yn = ys.fit_transform(y)
y_new = np.tile(yn, (20000, 1))
1
2
3
4
5
6

3.建立模型，进行编译，训练模型

• 可以先将数据集进行划分：训练集，交叉验证集，测试集
• 定义层数，层的神经元，激活函数，lambada，损失函数，优化器，训练次数

X_train, X_, y_train, y_ = train_test_split(X_new,y_new,test_size=0.4, random_state=1)
X_cv, X_test, y_cv, y_test = train_test_split(X_,y_,test_size=0.50, random_state=1)
# print(X_train.shape,y_train.shape)

model = Sequential([
    Dense(units=32,activation="relu",kernel_regularizer=tf.keras.regularizers.L2(0.1)),
    Dense(units=16, activation="relu", kernel_regularizer=tf.keras.regularizers.L2(0.1)),
    Dense(units=2)
])

model.compile(
    loss=tf.keras.losses.MeanSquaredError(),
    optimizer="adam"
)

model.fit(
    X_train,y_train,
    epochs=10
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.模型存储和调用

• 当你训练完模型后，可以对模型进行存储，这样就不用一直训练模型，去进行预测或者别的操作。然后新建文件进行调用即可

"""
当前文件
"""
pickle_out = open("model.p", "wb")
pickle.dump(model, pickle_out)
pickle_out.close()

1
2
3
4
5
6
7

二、调用模型步骤 （Using_model.py）

1.调用模型

• 使用pickle将模型存储为model.p文件

import numpy as np
from sklearn.model_selection import train_test_split
import pickle

from sklearn.preprocessing import StandardScaler

pickle_in = open("model.p", "rb")
model = pickle.load(pickle_in)
1
2
3
4
5
6
7
8

2.模型预测

• 由于存储了模型，这样每次预测的时候只需要调用模型即可，但是我们需要重新导入数据集，重复训练模型的步骤1和2

def load_x(filename):
    X = np.loadtxt(filename, delimiter=',')
    return X

def load_y(filename):
    y = np.loadtxt(filename, delimiter=',')
    return y
def eval_mse(y, yhat):
    m = len(y)
    err = (yhat - y) ** 2
    err = np.sum(err)
    err = err / (2 * m)
    return (err)

X = load_x("dataX.txt")
y = load_y("datay.txt")

Xs = StandardScaler()
Xn = Xs.fit_transform(X)
X_new = np.tile(Xn, (20000, 1))
ys = StandardScaler()
yn = ys.fit_transform(y)
y_new = np.tile(yn, (20000, 1))

X_train, X_, y_train, y_ = train_test_split(X_new,y_new,test_size=0.4, random_state=1)
X_cv, X_test, y_cv, y_test = train_test_split(X_,y_,test_size=0.50, random_state=1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

• 对数据集进行归一化后，预测所输入的特征也要先进行归一化，得到的也是归一化后的预测值，此时需要进行逆归一化，得到结果
• 还需注意的是，当你输入一个特征的时候不能对这一个特征进行归一化，需要把这个特征加入的特征的数据集里，然后重新计算均值和方差，得到归一化的结果，然后将逆归一化的预测结果加入到目标数据集

filename = "dataX.txt"
a = float(input("please Input One values: "))
b = float(input("please Input One values: "))
c = float(input("please Input One values: "))

with open(filename,'a') as file_object:
    file_object.write(f"\n{a},{b},{c}")
X = load_x("dataX.txt")
Xs_new = StandardScaler()
Xn_new = Xs.fit_transform(X)



x_norm = np.array([Xn_new[-1]])
y_pre = model.predict(x_norm)
y_INV = ys.inverse_transform(y_pre)
print(y_INV)

filename= "datay.txt"
with open(filename,'a') as file_object:
    file_object.write(f"\n{y_INV[0][0]},{y_INV[0][1]}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.计算模型输出损失，训练集，测试集的均方误差

• 看看模型训练的效果

s = model.evaluate(X_train, y_train, verbose=0)
print(s)

y_pre_cv = model.predict(X_cv)
err_cv = eval_mse(y_cv,y_pre_cv)
print(err_cv)

y_pre_train = model.predict(X_train)
err_train = eval_mse(y_train,y_pre_train)
print(err_train)

y_pre_test = model.predict(X_test)
y_pre = ys.inverse_transform(y_pre_test)
y_test = ys.inverse_transform(y_test)
print(f"Predictions of Test:\n{y_pre} \n True Values:\n{y_test}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 看到预测的测试集结果是有误差的，但是不大
  

• 输入[73.39，3.9635，0.988]，[75.55，4.0975，1.0268]得到预测结果。
  

总结

• 可以通过增多神经网络的层数，每一次的神经元，调整lambada参数，来让神经网络的预测更加的准确
• 通过观察训练集的误差和交叉验证集的误差，如果大概相等且很小，那么恭喜！你的模型训练的很好了！