linear regression and logistic regression with pytorch

import torch
import torch.nn.functional as F
from torch.autograd import variable

x = Variable(torch.Tensor([1]), requires_grad = True)
w = Variable(torch.Tensor([2]), requires_grad = True)
b = Variable(torch.Tensor([3]), requires_grad = True)

y = w * x + b
# y = 2 * 1 + 3
y.backward()

print(x.grad)
print(w.grad)
print(b.grad)

x = Variable(torch.Tensor([0]), requires_grad = True)
w = Variable(torch.Tensor([2]), requires_grad = True)
b = Variable(torch.Tensor([5]), requires_grad = True)
y = w*x*x + b
y.backward(torch.FloatTensor([1]))
print(x.grad)

x = Variable(torch.randn(3), requires_grad = True)
print(x)

y = 2*x
y.backward(torch.FloatTensor([1,1,1]))
print(x.grad)

y.backward(torch.FloatTensor([0.1, 0.2, 0.3]))
print(x.grad)

import matplotlib.pyplot as plt
import numpy as np

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)

plt.scatter(x_train, y_train, )

#首先把numpyarray类型的数据转换成torch.tensor,使用torch.from_numpy方法
x_train = torch.from_numpy(x_train)
y_train = torch.from_numpy(y_train)

class LinearRegression(torch.nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1)
        # basicly this is x*w+b=y
    def forward(self, x):
        out = self.linear(x)
        return out

# class LinearRegression(torch.nn.Module):
#     def __init__(self, input_num, hidden_num, output_num):
#         super(LinearRegression, self).__init__()
#         self.linear1 = nn.Linear(input_num, hidden_num)
#         self.linear2 = nn.Linear(hidden_num, output_num)
#         # basicly this is x*w+b=y
#     def forward(self, x):
#         x = F.relu(self.linear1(x))
#         out = (self.linear2(x))
#         return out

if torch.cuda.is_available():
    model = LinearRegression().cuda()

net = LinearRegression()
print(net)

criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(net.parameters(), lr = 1e-3)

num_epochs = 100
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 = net(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]))
        # loss is a Variable, by calling data, we get the data of the Variable

net.eval() # evaluate mode
predict = net(Variable(x_train))
predict = predict.data.numpy()
plt.scatter(x_train.numpy(), y_train.numpy())
plt.plot(x_train.numpy(), predict, )
plt.show()

n_data = torch.ones(100, 2)
x0 = torch.normal(2*n_data, 1)      # class0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # class0 y data (tensor), shape=(100, 1)
x1 = torch.normal(-2*n_data, 1)     # class1 x data (tensor), shape=(100, 2)
y1 = torch.ones(100)                # class1 y data (tensor), shape=(100, 1)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating
# print(x.numpy().shape)
y = torch.cat((y0, y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer

plt.scatter(x.numpy()[:,0], x.numpy()[:,1], c = y)

class LogisticRegression(torch.nn.Module):
    def __init__(self, input_num, hidden_num, output_num):
        super(LogisticRegression, self).__init__()
        self.hidden = torch.nn.Linear(input_num, hidden_num)
        self.output = torch.nn.Linear(hidden_num, output_num)
    
    def forward(self, x):
        x = torch.nn.functional.relu(self.hidden(x))
        out = self.output(x)
        return x

net = LogisticRegression(2, 10, 2)
print(net)

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr = 1e-1)

if torch.cuda.is_available():
    inputx = Variable(x).cuda()
    targety = Variable(y).cuda()
else:
    inputx = Variable(x)
    targety = Variable(y)
num_epochs = 1000
for epoch in range(num_epochs):
    # forward
    out = net(inputx)
    loss = criterion(out, targety)
    # backward
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if epoch % 40 == 0:
        print(‘Epoch[{}/{}], loss: {:.6f}‘.format(epoch, num_epochs, loss.data[0]))
#     if epoch % 20 == 0:
# plot and show learning process
plt.cla()
prediction = torch.max(out, 1)[1]
# print(prediction.data.numpy().shape)
pred_y = prediction.data.numpy().squeeze()
# print(pred_y.shape)
target_y = y.numpy()
plt.scatter(x.numpy()[:, 0], x.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap=‘RdYlGn‘)
accuracy = sum(pred_y == target_y)/200.
plt.text(1.5, -4, ‘Accuracy=%.2f‘ % accuracy, fontdict={‘size‘: 20, ‘color‘:  ‘red‘})
#         plt.pause(0.1)

# plt.ioff()
plt.show()

net.eval()
xx = np.linspace(-4,4,10000).reshape(10000, 1)
yy = 4*np.sin(xx*100).reshape(10000, 1)
xy = np.concatenate((xx, yy), axis = 1)
xy = torch.from_numpy(xy).type(torch.FloatTensor)
xy = Variable(xy)
pred = net(xy)
# print(pred.data.numpy().shape)
# print(pred[:6, :])
pred = torch.max(pred, 1)[1]
# print(len(pred))

# print(len(pred))
# print(pred.data.numpy().shape)
# print(pred[:6])
pred = pred.data.numpy().squeeze()
plt.scatter(xy.data.numpy()[:, 0], xy.data.numpy()[:, 1], c = pred, s = 100, lw = 0, cmap = ‘RdYlGn‘)
plt.show()