线性回归的求解(tensorflow)

import tensorflow as tf
import matplotlib.pyplot as plt


# 实际的线
TRUE_W = 3.0
TRUE_B = 2.0

NUM_EXAMPLES = 1000

# 随机向量x
x = tf.random.uniform(shape=[NUM_EXAMPLES],
                      minval=-3,
                      maxval=3)

# 生成噪声
noise = tf.random.normal(shape=[NUM_EXAMPLES])

# 计算y
y = x * TRUE_W + TRUE_B + noise



# 绘制所有的数据
%config InlineBackend.figure_format = 'retina'
plt.grid(True)
plt.scatter(x, y, c="b")
plt.show()

"""
使用 tf.Variable 代表模型中的所有权重。tf.Variable 能够存储值，
并根据需要以张量形式提供它。
使用 tf.Module 封装变量和计算。
您可以使用任何Python对象，但是通过这种方式可以轻松保存它。
"""
class MyModel(tf.Module):
  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # 初始化权重值为`5.0`，偏差值为`0.0`
    # 实际项目中，应该随机初始化
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  def __call__(self, x):
    return self.w * x + self.b

model = MyModel()

# 列出变量tf.modules的内置变量聚合
print("Variables:", model.variables)

# 验证模型是否有效
assert model(3.0).numpy() == 15.0

"""
定义损失函数
损失函数衡量给定输入的模型输出与目标输出的匹配程度。
目的是在训练过程中尽量减少这种差异。
定义标准的L2损失，也称为“均方误差”:
"""

# 计算整个批次的单个损失值
def loss(target_y, predicted_y):
  return tf.reduce_mean(tf.square(target_y - predicted_y))


# 在训练模型之前，您可以可视化损失值。使用红色绘制模型的预测值，使用蓝色绘制训练数据。
plt.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(model(x), y).numpy())


# 给定一个可调用的模型，输入，输出和学习率...
def train(model, x, y, learning_rate):

  with tf.GradientTape() as t:
    # 可训练变量由GradientTape自动跟踪
    current_loss = loss(y, model(x))

  # 使用GradientTape计算相对于W和b的梯度
  dw, db = t.gradient(current_loss, [model.w, model.b])

  # 减去由学习率缩放的梯度
  model.w.assign_sub(learning_rate * dw)
  model.b.assign_sub(learning_rate * db)


# 为了了解训练，您可以发送同一批* x 和 y * 经过循环训练，同时查看W和b的变化情况。

model = MyModel()

# 收集W值和b值的历史记录以供以后绘制
Ws, bs = [], []
epochs = range(10)

# 定义用于训练的循环
def training_loop(model, x, y):

  for epoch in epochs:
    # 用单个大批次处理更新模型
    train(model, x, y, learning_rate=0.1)

    # 在更新之前进行跟踪
    Ws.append(model.w.numpy())
    bs.append(model.b.numpy())
    current_loss = loss(y, model(x))

    print("Epoch %2d: W=%1.2f b=%1.2f, loss=%2.5f" %
          (epoch, Ws[-1], bs[-1], current_loss))


print("Starting: W=%1.2f b=%1.2f, loss=%2.5f" %
      (model.w, model.b, loss(y, model(x))))

# 开始训练
training_loop(model, x, y)

# 绘制
plt.plot(epochs, Ws, "r",
         epochs, bs, "b")

plt.plot([TRUE_W] * len(epochs), "r--",
         [TRUE_B] * len(epochs), "b--")

plt.legend(["W", "b", "True W", "True b"])
plt.show()

# 可视化训练后的模型如何执行
plt.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(model(x), y).numpy())

Starting: W=5.00 b=0.00, loss=16.64539
Epoch  0: W=3.80 b=0.39, loss=5.25020
Epoch  1: W=3.33 b=0.71, loss=2.79669
Epoch  2: W=3.14 b=0.95, loss=1.99691
Epoch  3: W=3.06 b=1.15, loss=1.60772
Epoch  4: W=3.03 b=1.31, loss=1.37814
Epoch  5: W=3.02 b=1.43, loss=1.23432
Epoch  6: W=3.02 b=1.53, loss=1.14276
Epoch  7: W=3.02 b=1.62, loss=1.08424
Epoch  8: W=3.02 b=1.68, loss=1.04679
Epoch  9: W=3.02 b=1.73, loss=1.02283

Current loss: 1.022830

​