python3+TensorFlow 2.x（二）回归模型

回归算法

1、线性回归 (Linear Regression)

一元线性回归举例

2、非线性回归

3、回归分类

回归算法

回归算法用于预测连续的数值输出。回归分析的目标是建立一个模型，以便根据输入特征预测目标变量，在使用 TensorFlow 2.x 实现线性回归模型时，通常的步骤包括数据预处理、模型构建、训练和评估。

1、线性回归 (Linear Regression)

概述：线性回归是最基本的回归算法之一，假设目标变量与输入特征之间存在线性关系。

模型形式：y= $\beta _{0}$ + $\beta _{1}x_{1}$ +...+ $\beta _{n}x_{n}$ +ϵ，其中 y 是目标变量，x 是特征，βi是权重，ϵ 是误差项。

一元线性回归举例

实现步骤：

导入必要的库。
生成或加载数据预处理：使用生成的线性数据集。生成了一个简单的线性关系 y = 2x + 1，并加上了一些噪声来模拟实际的观测数据。np.linspace 生成 100 个从 0 到 10 的点，np.random.normal 用于生成随机噪声。数据处理：使用 X.reshape(-1, 1) 将 X 变成二维数组，以适应 TensorFlow 的输入要求。

构建线性回归模型：使用 tf.keras.Sequential 创建一个简单的线性模型。只使用一个 Dense 层来表示线性回归，其中 input_dim=1 指明输入特征的维度为 1，output_dim=1 表示输出只有一个预测值。

编译模型：设置损失函数和优化器。使用了 adam 优化器，这是一个常用且效果不错的优化器。损失函数选择 mean_squared_error，这是回归问题中常见的损失函数。

训练模型：使用训练数据来训练模型。model.fit 方法用于训练模型。设置了 200 个 epoch 和10 的批次大小。

评估模型：通过测试数据评估模型性能。model.evaluate 会返回训练集的损失值，用来评估训练过程中的效果.

预测结果：使用训练好的模型进行预测。使用 matplotlib 绘制训练过程中每个 epoch 的损失变化情况，以便观察模型训练的收敛过程，使用 model.predict 来预测训练集上的输出，然后将预测结果与真实数据一起绘制出来，查看模型的拟合效果

import numpy as np
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

# 1. 生成数据：y = 2x + 1
np.random.seed(42)
X = np.linspace(0, 10, 100)  # 生成100个点，范围是[0, 10]
Y = 2 * X + 1 + np.random.normal(0, 1, X.shape[0])  # y = 2x + 1，加上一些噪声

# 2. 数据预处理：将数据转化为TensorFlow的张量（也可以直接使用NumPy数组）
X_train = X.reshape(-1, 1)  # 特征，转换成二维数组
Y_train = Y.reshape(-1, 1)  # 标签，转换成二维数组

# 3. 构建线性回归模型
model = keras.Sequential([
    keras.layers.Dense(1, input_dim=1)  # 只有一个输入特征，输出一个值
])

# 4. 编译模型：选择损失函数和优化器
model.compile(optimizer='adam', loss='mean_squared_error')

# 5. 训练模型
history = model.fit(X_train, Y_train, epochs=200, batch_size=10, verbose=0)

# 6. 评估模型
loss = model.evaluate(X_train, Y_train)
print(f"Final training loss: {loss}")

# 7. 绘制训练过程中的损失变化
plt.plot(history.history['loss'])
plt.title('Training Loss Over Epochs')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.show()

# 8. 预测结果
Y_pred = model.predict(X_train)

# 9. 可视化真实数据和预测结果
plt.scatter(X_train, Y_train, color='blue', label='Actual Data')
plt.plot(X_train, Y_pred, color='red', label='Predicted Line')
plt.title('Linear Regression with TensorFlow 2')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.show()

2、非线性回归

创建合成数据集：使用 NumPy 生成从 -3 到 3 的 100 个点，并计算对应的 y 值为sin(x) 加上一些噪声。

划分训练集和测试集：使用 train_test_split 将数据集划分为训练集和测试集，比例为 80% 训练，20% 测试。

构建曲线拟合模型：使用 tf.keras.Sequential 创建一个简单的神经网络模型，包含两个隐藏层，每层有 64 个神经元，激活函数为 ReLU，最后一层为输出层。

编译模型：使用 Adam 优化器和均方误差损失函数编译模型。

训练模型：使用 fit 方法训练模型，设置训练轮数为 200，批次大小为 10。

进行预测：使用 predict 方法对测试集进行预测。可视化预测结果，使用 Matplotlib 绘制实际值和预测值的散点图。

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

# 1. 创建合成数据集
np.random.seed(0)
X = np.linspace(-3, 3, 100)  # 生成从-3到3的100个点
y = np.sin(X) + np.random.normal(0, 0.1, X.shape)  # y = sin(x) + 噪声

# 2. 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 3. 构建曲线拟合模型
# 将输入数据转换为二维数组
X_train = X_train.reshape(-1, 1)
X_test = X_test.reshape(-1, 1)

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(1,)),  # 隐藏层
    tf.keras.layers.Dense(64, activation='relu'),  # 隐藏层
    tf.keras.layers.Dense(1)  # 输出层
])

# 4. 编译模型
model.compile(optimizer='adam', loss='mean_squared_error')

# 5. 训练模型
model.fit(X_train, y_train, epochs=200, batch_size=10, verbose=0)

# 6. 进行预测
predictions = model.predict(X_test)

# 7. 可视化预测结果
plt.figure(figsize=(10, 6))
plt.scatter(X_test, y_test, color='blue', label='Actual Values')  # 实际值
plt.scatter(X_test, predictions, color='red', label='Predicted Values')  # 预测值
plt.title('Curve Fitting Regression')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()

3、回归分类

import numpy as np
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification, make_regression
import matplotlib.pyplot as plt

# 生成回归数据集
X_reg, y_reg = make_regression(n_samples=1000, n_features=1, noise=10, random_state=42)

# 生成分类数据集
X_class, y_class = make_classification(n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=42)

# 划分训练集和测试集
X_reg_train, X_reg_test, y_reg_train, y_reg_test = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)
X_class_train, X_class_test, y_class_train, y_class_test = train_test_split(X_class, y_class, test_size=0.2, random_state=42)

# 创建线性回归模型
model_reg = tf.keras.Sequential([
    tf.keras.layers.Dense(1, input_shape=(1,))  # 输入特征为 1，输出为 1
])

# 编译模型
model_reg.compile(optimizer='adam', loss='mean_squared_error')

# 训练模型
model_reg.fit(X_reg_train, y_reg_train, epochs=100, batch_size=32, verbose=1)

# 评估模型
loss_reg = model_reg.evaluate(X_reg_test, y_reg_test, verbose=0)
print(f'回归模型测试集损失: {loss_reg:.4f}')

# 可视化回归结果
plt.scatter(X_reg, y_reg, color='blue', label='Data points')
plt.scatter(X_reg_test, model_reg.predict(X_reg_test), color='red', label='Predictions')
plt.title('Linear Regression Results')
plt.xlabel('Feature')
plt.ylabel('Target')
plt.legend()
plt.show()

# 创建逻辑回归模型
model_class = tf.keras.Sequential([
    tf.keras.layers.Dense(1, activation='sigmoid', input_shape=(2,))  # 输入特征为 2，输出为 1
])

# 编译模型
model_class.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 训练模型
model_class.fit(X_class_train, y_class_train, epochs=100, batch_size=32, verbose=1)

# 评估模型
loss_class, accuracy_class = model_class.evaluate(X_class_test, y_class_test, verbose=0)
print(f'分类模型测试集损失: {loss_class:.4f}, 测试集准确率: {accuracy_class:.4f}')

# 可视化分类数据点
plt.scatter(X_class_train[y_class_train == 0][:, 0], X_class_train[y_class_train == 0][:, 1], color='blue', label='Class 0', alpha=0.5)
plt.scatter(X_class_train[y_class_train == 1][:, 0], X_class_train[y_class_train == 1][:, 1], color='red', label='Class 1', alpha=0.5)

# 绘制决策边界
x_min, x_max = X_class[:, 0].min() - 1, X_class[:, 0].max() + 1
y_min, y_max = X_class[:, 1].min() - 1, X_class[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))
Z = model_class.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, levels=[0, 0.5, 1], alpha=0.2, colors=['blue', 'red'])
plt.title('Logistic Regression Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.show()

make_classification 是 sklearn.datasets 模块中的一个函数，用于生成用于分类的合成数据集。可以通过不同的参数来控制生成数据的特性。

参数解释：n_samples: 生成的样本数量。
n_features: 特征的总数。设置为 2，表示每个样本有 2 个特征。
n_informative: 有效特征的数量，这些特征对分类任务有贡献。设置为 2，表示所有特征都是有效特征。
n_redundant: 冗余特征的数量，这些特征是通过线性组合生成的有效特征。设置为 0，表示没有冗余特征。
n_clusters_per_class: 每个类别的聚类数量。设置为 1，表示每个类别只有一个聚类。
random_state: 随机种子，用于确保结果的可重复性。设置为 42。

make_regression 是 sklearn.datasets 模块中的一个函数，用于生成用于回归的合成数据集。

参数解释：n_samples: 生成的样本数量。
n_features: 特征的总数。比如设置为 1，表示每个样本有 1 个特征。
n_informative: 有效特征的数量，这些特征对目标变量有贡献。比如设置为 1，表示所有特征都是有效特征。
n_targets: 目标变量的数量。默认值为 1，表示生成一个目标变量。
bias: 截距项，表示模型的偏置。可以设置为一个常数，比如 0。
noise: 添加到输出中的噪声的标准差。可以设置为一个浮点数，如 0.1表示添加一定的随机噪声。
random_state: 随机种子，用于确保结果的可重复性。可以设置为一个整数，比如 42。