逻辑回归是一种经典的分类算法，广泛应用于二分类问题。本文将介绍如何使用TensorFlow框架实现逻辑回归模型，并通过动态绘制决策边界和损失曲线来直观地观察模型的训练过程。

数据准备

首先，我们准备两类数据点，分别表示两个不同的类别。这些数据点将作为模型的输入特征。

# 1.散点输入
class1_points=np.array([[1.9,1.2],
                        [1.5,2.1],
                        [1.9,0.5],
                        [1.5,0.9],
                        [0.9,1.2],
                        [1.1,1.7],
                        [1.4,1.1]])
class2_points=np.array([[3.2,3.2],
                        [3.7,2.9],
                        [3.2,2.6],
                        [1.7,3.3],
                        [3.4,2.6],
                        [4.1,2.3],
                        [3.0,2.9]])

将两类数据点合并为一个矩阵，并为每个数据点分配相应的标签（0或1）。

#不用单独提取出x1_data 和x2_data
#框架会根据输入特征数自动提取
x_train=np.concatenate((class1_points,class2_points),axis=0)
y_train=np.concatenate((np.zeros(len(class1_points)),np.ones(len(class2_points))))

将数据转换为TensorFlow张量，以便在模型中使用。

import tensorflow as tf

x_train_tensor = tf.convert_to_tensor(x_train, dtype=tf.float32)
y_train_tensor = tf.convert_to_tensor(y_train, dtype=tf.float32)

模型定义

使用TensorFlow的tf.keras模块定义逻辑回归模型。模型包含一个输入层和一个输出层，输出层使用sigmoid激活函数。

def LogisticRegreModel():
    input = tf.keras.Input(shape=(2,))
    fc = tf.keras.layers.Dense(1, activation='sigmoid')(input)
    lr_model = tf.keras.models.Model(inputs=input, outputs=fc)
    return lr_model

model = LogisticRegreModel()

定义优化器和损失函数。这里使用随机梯度下降优化器和二元交叉熵损失函数。

opt = tf.keras.optimizers.SGD(learning_rate=0.01)
model.compile(optimizer=opt, loss="binary_crossentropy")

训练过程

训练模型时，我们记录每个epoch的损失值，并动态绘制决策边界和损失曲线。

 

import matplotlib.pyplot as plt

fig, (ax1, ax2) = plt.subplots(1, 2)

epochs = 500
epoch_list = []
epoch_loss = []

for epoch in range(1, epochs + 1):
    y_pre = model.fit(x_train_tensor, y_train_tensor, epochs=50, verbose=0)
    epoch_loss.append(y_pre.history["loss"][0])
    epoch_list.append(epoch)

    w1, w2 = model.get_weights()[0].flatten()
    b = model.get_weights()[1][0]

    slope = -w1 / w2
    intercept = -b / w2

    x_min, x_max = 0, 5
    x = np.array([x_min, x_max])
    y = slope * x + intercept

    ax1.clear()
    ax1.plot(x, y, 'r')
    ax1.scatter(x_train[:len(class1_points), 0], x_train[:len(class1_points), 1])
    ax1.scatter(x_train[len(class1_points):, 0], x_train[len(class1_points):, 1])

    ax2.clear()
    ax2.plot(epoch_list, epoch_loss, 'b')
    plt.pause(1)

结果展示

训练完成后，决策边界图将显示模型如何将两类数据分开，损失曲线图将显示模型在训练过程中的损失值变化。生成结果基本如图所示：

通过动态绘制决策边界和损失曲线，我们可以直观地观察模型的训练过程，了解模型如何逐渐学习数据的分布并优化决策边界。

总结

本文介绍了如何使用TensorFlow实现逻辑回归模型，并通过动态绘制决策边界和损失曲线来观察模型的训练过程。逻辑回归是一种简单而有效的分类算法，适用于二分类问题。通过TensorFlow框架，我们可以轻松地实现和训练逻辑回归模型，并利用其强大的功能来优化模型的性能。

---

完整代码

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
# 1.散点输入
class1_points=np.array([[1.9,1.2],
                        [1.5,2.1],
                        [1.9,0.5],
                        [1.5,0.9],
                        [0.9,1.2],
                        [1.1,1.7],
                        [1.4,1.1]])
class2_points=np.array([[3.2,3.2],
                        [3.7,2.9],
                        [3.2,2.6],
                        [1.7,3.3],
                        [3.4,2.6],
                        [4.1,2.3],
                        [3.0,2.9]])

#不用单独提取出x1_data 和x2_data
#框架会根据输入特征数自动提取
x_train=np.concatenate((class1_points,class2_points),axis=0)
y_train=np.concatenate((np.zeros(len(class1_points)),np.ones(len(class2_points))))
#转化为张量
x_train_tensor=tf.convert_to_tensor(x_train,dtype=tf.float32)
y_train_tensor=tf.convert_to_tensor(y_train,dtype=tf.float32)

#2.定义前向模型
# 使用类的方式
# 先设置一下随机数种子
seed=0
tf.random.set_seed(0)

def LogisticRegreModel():
    input=tf.keras.Input(shape=(2,))
    fc=tf.keras.layers.Dense(1,activation='sigmoid')(input)
    lr_model=tf.keras.models.Model(inputs=input,outputs=fc)
    return lr_model
#实例化网络
model=LogisticRegreModel()
#3.定义损失函数和优化器
#定义优化器
#需要输入模型参数和学习率
lr=0.1
opt=tf.keras.optimizers.SGD(learning_rate=0.01)
model.compile(optimizer=opt,loss="binary_crossentropy")



# 最后画图
fig,(ax1,ax2)=plt.subplots(1,2)
#训练
epoches=500
epoch_list=[]
epoch_loss=[]
for epoch in range(1,epoches+1):
    # verbose=0 进度条不显示  epochs迭代次数
    y_pre=model.fit(x_train_tensor,y_train_tensor,epochs=50,verbose=0)
    # print(y_pre.history["loss"])
    epoch_loss.append(y_pre.history["loss"][0])
    epoch_list.append(epoch)
    w1,w2=model.get_weights()[0].flatten()
    b=model.get_weights()[1][0]

    #画左图
    # 使用斜率和截距画直线
    #目前将x2当作y轴 x1当作x轴
    # w1*x1+w2*x2+b=0
    #求出斜率和截距
    slope=-w1/w2
    intercept=-b/w2
    #绘制直线 开始结束位置
    x_min,x_max=0,5
    x=np.array([x_min,x_max])
    y=slope*x+intercept
    ax1.clear()
    ax1.plot(x,y,'r')
    #画散点图
    ax1.scatter(x_train[:len(class1_points),0],x_train[:len(class1_points),1])
    ax1.scatter(x_train[len(class1_points):, 0],x_train[len(class1_points):, 1])


    #画右图
    ax2.clear()
    ax2.plot(epoch_list,epoch_loss,'b')
    plt.pause(1)