update

Author: L1aoXingyu

cahpter3_MLP/linear_model.py

@@ -0,0 +1,72 @@
+__author__ = 'SherlockLiao'
+
+import torch
+from torch import nn, optim
+from torch.autograd import Variable
+import numpy as np
+import matplotlib.pyplot as plt
+
+x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
+                    [9.779], [6.182], [7.59], [2.167], [7.042],
+                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)
+
+y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
+                    [3.366], [2.596], [2.53], [1.221], [2.827],
+                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)
+
+
+x_train = torch.from_numpy(x_train)
+
+y_train = torch.from_numpy(y_train)
+
+
+# Linear Regression Model
+class LinearRegression(nn.Module):
+    def __init__(self):
+        super(LinearRegression, self).__init__()
+        self.linear = nn.Linear(1, 1)  # input and output is 1 dimension
+
+    def forward(self, x):
+        out = self.linear(x)
+        return out
+
+
+if torch.cuda.is_available():
+    model = LinearRegression().cuda()
+else:
+    model = LinearRegression()
+# 定义loss和优化函数
+criterion = nn.MSELoss()
+optimizer = optim.SGD(model.parameters(), lr=1e-4)
+
+# 开始训练
+num_epochs = 1000
+for epoch in range(num_epochs):
+    if torch.cuda.is_available():
+        inputs = Variable(x_train).cuda()
+        target = Variable(y_train).cuda()
+    else:
+        inputs = Variable(x_train)
+        target = Variable(y_train)
+
+    # forward
+    out = model(inputs)
+    loss = criterion(out, target)
+    # backward
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+    if (epoch+1) % 20 == 0:
+        print('Epoch[{}/{}], loss: {:.6f}'
+              .format(epoch+1, num_epochs, loss.data[0]))
+
+model.eval()
+predict = model(Variable(x_train))
+predict = predict.data.numpy()
+plt.plot(x_train.numpy(), y_train.numpy(), 'ro', label='Original data')
+plt.plot(x_train.numpy(), predict, label='Fitting Line')
+plt.show()
+
+# 保存模型
+torch.save(model.state_dict(), './linear.pth')

cahpter3_MLP/poly_model.py

@@ -0,0 +1,103 @@
+__author__ = 'SherlockLiao'
+
+import torch
+from torch import nn, optim
+from torch.autograd import Variable
+import numpy as np
+import matplotlib.pyplot as plt
+
+W_target = torch.FloatTensor([0.5, 3, 2.4]).unsqueeze(1)
+b_target = torch.FloatTensor([0.9])
+
+
+def make_features(x):
+    """Builds features i.e. a matrix with columns [x, x^2, x^3]."""
+    x = x.unsqueeze(1)
+    return torch.cat([x ** i for i in range(1, 4)], 1)
+
+
+def f(x):
+    """Approximated function."""
+    return x.mm(W_target) + b_target[0]
+
+
+# plot function curve and fitting curve
+def plot_function(model):
+    x_data = make_features(torch.arange(-1, 1, 0.01))
+    y_data = f(x_data)
+    if torch.cuda.is_available():
+        y_pred = model(Variable(x_data).cuda())
+    x = torch.arange(-1, 1, 0.01).numpy()
+    y = y_data.numpy()
+    y_p = y_pred.cpu().data.numpy()
+    plt.xlabel('x')
+    plt.ylabel('y')
+    plt.plot(x, y, 'r', label='real curve')
+    plt.plot(x, y_p, label='fitting curve')
+    plt.legend(loc='best')
+    plt.show()
+
+
+# print funciton describe
+def poly_desc(w, b):
+    des = 'y = {:.2f} + {:.2f}*x + {:.2f}*x^2 + {:.2f}*x^3'.format(
+        b[0], w[0], w[1], w[2])
+    return des
+
+
+# get data
+def get_batch(batch_size=32):
+    """Builds a batch i.e. (x, f(x)) pair."""
+    random = torch.randn(batch_size)
+    x = make_features(random)
+    y = f(x)
+    if torch.cuda.is_available():
+        return Variable(x).cuda(), Variable(y).cuda()
+    else:
+        return Variable(x), Variable(y)
+
+
+# Define model
+class poly_model(nn.Module):
+    def __init__(self):
+        super(poly_model, self).__init__()
+        self.poly = nn.Linear(3, 1)
+
+    def forward(self, x):
+        out = self.poly(x)
+        return out
+
+
+if torch.cuda.is_available():
+    model = poly_model().cuda()
+else:
+    model = poly_model()
+
+criterion = nn.MSELoss()
+optimizer = optim.SGD(model.parameters(), lr=1e-3)
+
+epoch = 0
+while True:
+    # Get data
+    batch_x, batch_y = get_batch()
+
+    # Forward pass
+    output = model(batch_x)
+    loss = criterion(output, batch_y)
+    print_loss = loss.data[0]
+
+    # Reset gradients
+    optimizer.zero_grad()
+    # Backward pass
+    loss.backward()
+    # update parameters
+    optimizer.step()
+    epoch += 1
+    if print_loss < 1e-3:
+        break
+
+print('Loss: {:.6f} after {} batches'.format(print_loss, epoch))
+print('==> Learned function:\t' + poly_desc(model.poly.weight.data.view(-1),
+                                            model.poly.bias.data))
+print('==> Actual function:\t' + poly_desc(W_target.view(-1), b_target))
+plot_function(model)