linear regression and logistic regression with pytorch
阿新 • • 發佈:2018-01-21
write tex rom array類 var form cit basic ons
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)
requires_grad = False(default)
默認是不對其求梯度的,除非聲明為True
y = w * x + b
# y = 2 * 1 + 3
y.backward()
y.backward
就是自動求導
print(x.grad)
print(w.grad)
print(b.grad)
Variable containing:
2
[torch.FloatTensor of size 1]
Variable containing:
1
[torch.FloatTensor of size 1]
Variable containing:
1
[torch.FloatTensor of size 1]
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)
Variable containing:
0
[torch.FloatTensor of size 1]
x = Variable(torch.randn(3), requires_grad = True)
print(x)
Variable containing: -0.9882 -1.1375 -0.4344 [torch.FloatTensor of size 3]
y = 2*x
y.backward(torch.FloatTensor([1,1,1]))
print(x.grad)
Variable containing:
2
2
2
[torch.FloatTensor of size 3]
grad can be implicitly created only for scalar outputs
you have to explicitly write torch.FloatTensor([1,1,1])
y.backward(torch.FloatTensor([0.1, 0.2, 0.3]))
print(x.grad)
Variable containing:
2.2000
2.4000
2.6000
[torch.FloatTensor of size 3]
gradient will accumulate somehow
two ways of saving a model
save both the model and the parameters
torch.save(model, ‘./model.poth‘)
save only the parameters (save the state of the model)
torch.save(model.state_dict(), ‘./model_state.pth‘)
two ways of loading a model
- load both model and parameters
load_model = torch.load(‘model.pth‘) - load only parameters
????
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, )
<matplotlib.collections.PathCollection at 0x10b695f28>
#首先把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)
LinearRegression(
(linear): Linear(in_features=1, out_features=1)
)
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
epoch[20/100], loss: 0.300034
epoch[40/100], loss: 0.298694
epoch[60/100], loss: 0.297367
epoch[80/100], loss: 0.296054
epoch[100/100], loss: 0.294755
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)
<matplotlib.collections.PathCollection at 0x10d1b4dd8>
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)
LogisticRegression(
(hidden): Linear(in_features=2, out_features=10)
(output): Linear(in_features=10, out_features=2)
)
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()
Epoch[0/1000], loss: 3.279978
Epoch[40/1000], loss: 0.165580
Epoch[80/1000], loss: 0.085501
Epoch[120/1000], loss: 0.059977
Epoch[160/1000], loss: 0.047022
Epoch[200/1000], loss: 0.039068
Epoch[240/1000], loss: 0.033637
Epoch[280/1000], loss: 0.029672
Epoch[320/1000], loss: 0.026636
Epoch[360/1000], loss: 0.024226
Epoch[400/1000], loss: 0.022261
Epoch[440/1000], loss: 0.020624
Epoch[480/1000], loss: 0.019237
Epoch[520/1000], loss: 0.018045
Epoch[560/1000], loss: 0.017008
Epoch[600/1000], loss: 0.016096
Epoch[640/1000], loss: 0.015287
Epoch[680/1000], loss: 0.014565
Epoch[720/1000], loss: 0.013916
Epoch[760/1000], loss: 0.013329
Epoch[800/1000], loss: 0.012795
Epoch[840/1000], loss: 0.012310
Epoch[880/1000], loss: 0.011866
Epoch[920/1000], loss: 0.011458
Epoch[960/1000], loss: 0.011080
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()
linear regression and logistic regression with pytorch