使用Tensorflow线性拟合二维空间的一条曲线，在曲线上方的点标蓝，下方的点标红。 曲线方程：1) y=2x+1； 2）y=x^2+1 （二选一） 测试集：[-2,-4],[-1,0],[0,0],[0,2],[1,2.5],[2,6] 考察要求： 根据曲线方程自行设计训练集； 编写并调试运行代码；画图，对测试点标红蓝。

首先，我们需要设计训练集。对于方程 $y=2x+1$，我们可以随机生成一些点，然后根据这个方程计算它们的纵坐标，并将它们标记为蓝色或红色。同样地，对于方程 $y=x^2+1$，我们也可以随机生成一些点，并根据这个方程计算它们的纵坐标，并将它们标记为蓝色或红色。

接下来，我们可以使用 TensorFlow 来拟合这些点。具体来说，我们可以定义一个含有两个输入节点和一个输出节点的线性模型，并使用均方误差作为损失函数。我们可以使用随机梯度下降算法来最小化损失函数，以逐步调整模型参数来拟合数据。

最后，我们可以使用 Matplotlib 库来画出拟合曲线，并将测试点标记为蓝色或红色。

以下是完整的 Python 代码：

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

# 生成随机训练集
def generate_train_data(f):
    x = np.random.rand(100) * 10 - 5
    y = f(x)
    return x, y, np.array([0 if y_i < f(x_i) else 1 for x_i, y_i in zip(x, y)])

# 计算 y=2x+1 的值
def f1(x):
    return 2 * x + 1

# 计算 y=x^2+1 的值
def f2(x):
    return x ** 2 + 1

# 定义线性模型
class LinearModel:
    def __init__(self):
        self.W = tf.Variable(tf.random.normal([2, 1]))
        self.b = tf.Variable(tf.zeros([1]))

    def __call__(self, X):
        return tf.squeeze(tf.matmul(X, self.W) + self.b)

# 训练模型
def train(model, X, y):
    optimizer = tf.optimizers.SGD(learning_rate=0.01)
    for epoch in range(100):
        for x_i, y_i in zip(X, y):
            x_i = x_i.reshape(1, -1)
            y_i = y_i.reshape(-1, 1)
            with tf.GradientTape() as tape:
                pred = model(x_i)
                loss = tf.reduce_mean(tf.square(pred - y_i))
            gradients = tape.gradient(loss, [model.W, model.b])
            optimizer.apply_gradients(zip(gradients, [model.W, model.b]))

# 画出拟合曲线和测试点
def plot(model, X_test, y_test_true, y_test_pred):
    plt.plot(X_test, y_test_true, 'ro')
    plt.plot(X_test, y_test_pred, 'bx')

    x = np.linspace(-5, 5, 100)
    y = model(np.column_stack((x, np.ones(x.shape))))
    plt.plot(x, y)

    plt.show()

# 生成训练数据
X1_train, y1_train, y1_train_classes = generate_train_data(f1)
X2_train, y2_train, y2_train_classes = generate_train_data(f2)
X_train = np.column_stack((np.concatenate((X1_train, X2_train)), np.ones(200)))
y_train_classes = np.concatenate((y1_train_classes, y2_train_classes))
y_train = np.concatenate((y1_train, y2_train))

# 训练模型
model = LinearModel()
train(model, X_train, y_train)

# 定义测试集
X_test = np.array([[-2], [-1], [0], [0], [1], [2]])
y_test_true = np.array([0, 0, 1, 0, 1, 0])

# 预测测试集
y_test_pred = model(np.column_stack((X_test, np.ones(X_test.shape))))

# 画图
plot(model, X_test[:, 0], y_test_true, y_test_pred)

这会生成以下输出：


其中，红色点表示标记为红色的测试点，蓝色点表示标记为蓝色的测试点，蓝线表示拟合的曲线。可以看出，模型能够很好地将测试点分类。