深度学习,回顾
W = Variable(torch.randn(1),requires_grad=True)
b = Variable(torch.zeros(1),requires_grad=True)
def linar_model(x):
return w *x +b
def get_loss(y_,y):
return torch.mean((y_ - y )**2)
loss.backward()(反向求梯度)
for e in range(10):
Y_ = linear_model(x_train)
Loss = get_loss(y_,y_train)
w.grad.zero_()
b.grad.zero_()
Loss.backward()
w.data = w.data -le-2*w.grad.data
b.data = b.data -le-2*bgrad.data
Print(‘epoch:{},loss:{}’,format(e,loss.data[0])
import torch
import numpy as np
from torch.autograd import Variable
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)
w = Variable(torch.randn(1), requires_grad=True)
b = Variable(torch.zeros(1), requires_grad=True)
x_train = Variable(x_train)
y_train = Variable(y_train)
y_ = linear_model(x_train)
def get_loss(y_, y):
return torch.mean((y_ - y_train) ** 2)
loss = get_loss(y_, y_train)
loss.backward()
for e in range(10):
y_ = linear_model(x_train)
loss = get_loss(y_, y_train)
w.grad.zero_()
b.grad.zero_()
loss.backward()
w.data = w.data - 1e-2 * w.grad.data
b.data = b.data - 1e-2 * b.grad.data
print('epoch: {}, loss: {}'.format(e, loss.data[0]))
import torch
import torch.nn as nn
import numpy as np
from torch import optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision.datasets import mnist
from torchvision import transforms
import matplotlib.pyplot as plt
class Net(nn.Module):
def __init__(self, in_c=784, out_c=10):
super(Net, self).__init__()
self.fc1 = nn.Linear(in_c, 512)
self.act1 = nn.ReLU(inplace=True)
self.fc2 = nn.Linear(512, 256)
self.act2 = nn.ReLU(inplace=True)
self.fc3 = nn.Linear(256, 128)
self.act3 = nn.ReLU(inplace=True)
self.fc4 = nn.Linear(128, out_c)
def forward(self, x):
x = self.act1(self.fc1(x))
x = self.act2(self.fc2(x))
x = self.act3(self.fc3(x))
x = self.fc4(x)
return x
net = Net()
train_set = mnist.MNIST('./data', train=True, transform=transforms.ToTensor(), download=True)
test_set = mnist.MNIST('./data', train=False, transform=transforms.ToTensor(), download=True)
train_data = DataLoader(train_set, batch_size=64, shuffle=True)
test_data = DataLoader(test_set, batch_size=128, shuffle=False)
import random
for i in range(4):
ax = plt.subplot(2, 2, i+1)
idx = random.randint(0, len(train_set))
digit_0 = train_set[idx][0].numpy()
digit_0_image = digit_0.reshape(28, 28)
ax.imshow(digit_0_image, interpolation="nearest")
ax.set_title('label: {}'.format(train_set[idx][1]), fontsize=10, color='black')
plt.show()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=1e-2, weight_decay=5e-4)
losses = []
acces = []
eval_losses = []
eval_acces = []
nums_epoch = 20
for epoch in range(nums_epoch):
train_loss = 0
train_acc = 0
net = net.train()
for batch, (img, label) in enumerate(train_data):
img = img.reshape(img.size(0), -1)
img = Variable(img)
label = Variable(label)
out = net(img)
loss = criterion(out, label)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_loss += loss.item()
_, pred = out.max(1)
num_correct = (pred == label).sum().item()
acc = num_correct / img.shape[0]
if (batch + 1) % 200 ==0:
print('[INFO] Epoch-{}-Batch-{}: Train: Loss-{:.4f}, Accuracy-{:.4f}'.format(epoch + 1,
batch+1,
loss.item(),
acc))
train_acc += acc
losses.append(train_loss / len(train_data))
acces.append(train_acc / len(train_data))
eval_loss = 0
eval_acc = 0
for img, label in test_data:
img = img.reshape(img.size(0),-1)
img = Variable(img)
label = Variable(label)
out = net(img)
loss = criterion(out, label)
eval_loss += loss.item()
_, pred = out.max(1)
num_correct = (pred == label).sum().item()
acc = num_correct / img.shape[0]
eval_acc += acc
eval_losses.append(eval_loss / len(test_data))
eval_acces.append(eval_acc / len(test_data))
print('[INFO] Epoch-{}: Train: Loss-{:.4f}, Accuracy-{:.4f} | Test: Loss-{:.4f}, Accuracy-{:.4f}'.format(
epoch + 1, train_loss / len(train_data), train_acc / len(train_data), eval_loss / len(test_data),
eval_acc / len(test_data)))
lt.figure()
plt.suptitle('Test', fontsize=12)
ax1 = plt.subplot(1, 2, 1)
ax1.plot(eval_losses, color='r')
ax1.plot(losses, color='b')
ax1.set_title('Loss', fontsize=10, color='black')
ax2 = plt.subplot(1, 2, 2)
ax2.plot(eval_acces, color='r')
ax2.plot(acces, color='b')
ax2.set_title('Acc', fontsize=10, color='black')
plt.show()