Paddle 2.1 拟合线性函数

import numpy as np
import paddle
import paddle.nn as  nn
import matplotlib
import matplotlib.pyplot as plt

from paddle.io import DataLoader, Dataset

k = 3.2
b = 10


# 生成测试数据
x = [np.random.randn() for i in range(5000)]
y = [k * i + b for i in x]


# 定义数据集
class LineDataSet(Dataset):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __getitem__(self, idx):
        data =  paddle.to_tensor(self.x[idx], dtype='float32')
        label = paddle.to_tensor(self.y[idx], dtype='float32')
        return data, label 

    def __len__(self):
        return len(self.x)
    

# 定义网架
class LineNet(nn.Layer):
    def __init__(self):
        super(LineNet, self).__init__()
        self.fc = nn.Linear(1, 1)

    def forward(self, image, label=None):
        return self.fc(image)

    def show(self):
        print("w:%.2f, b:%.2f" % (self.fc.weight, self.fc.bias))


net = LineNet()
# 优化器

opt = paddle.optimizer.SGD(learning_rate=1e-3,
                            parameters=net.parameters())


dataset = LineDataSet(x, y)
loader = DataLoader(dataset,
                    shuffle=True,
                    batch_size= 20)


# 训练
for e in range(10):
    for i, (data, label) in enumerate(loader()):
        out = net(data)
        loss = nn.functional.mse_loss(out, label)
        loss.backward()
        opt.step()
        opt.clear_grad()
        print("Epoch {} batch {}: loss = {}".format(
            e, i, np.mean(loss.numpy())))
     

# 评估展示
net.eval()
x = np.array([np.random.randn() * 10 for i in range(5000)])
y = np.array([k * i + b for i in x])
z = np.array([net(paddle.to_tensor(i)).numpy()[0] for i in x])


plt.plot(x, y, color='blue', label="act")
plt.plot(x, z, color='red', label="eval")
plt.legend()
plt.show()

net.show()