第一部分代码
import torch
import torch.nn as nn
input = [3, 4, 6, 5, 7,
2, 4, 6, 8, 2,
1, 6, 7, 8, 4,
9, 7, 4, 6, 2,
3, 7, 5, 4, 1]
inputs = torch.Tensor(input).view(1, 1, 5, 5) # Batch Channel W H
conv_layer = nn.Conv2d(1, 1, kernel_size=3, padding=1, bias=False)
kernel = torch.Tensor([1, 2, 3, 4, 5, 6, 7, 8, 9]).view(1, 1, 3, 3) # 卷积核 O I W H
conv_layer.weight.data = kernel.data
output = conv_layer(inputs)
print(output)第二部分代码
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms
import torch.nn.functional as F # 激活函数relu
import torch.optim as optim
# # step1 准备数据集
batch_size = 32
transform = transforms.Compose([ # 将下列的内容构成pipline
transforms.ToTensor(), # 把原始数据转为张量 PIL图像0-255转为图像张量0-1
transforms.Normalize((0.1307, ), (0.3081, )) # 归一化 做normalization， 前为均值，后为标准差 数据标准化
])
train_dataset = datasets.MNIST(root='../dataset/mnist', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='../dataset/mnist', train=False, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
# # step2 设计模型
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.pool = nn.MaxPool2d(2)
self.fc = nn.Linear(320, 10)
def forward(self, x):
batch_size = x.size(0) # 1*28*28 样本数量
x = self.pool(F.relu(self.conv1(x))) # 10*24*24 -> 10*12*12
x = self.pool(F.relu(self.conv2(x))) # 20*8*8 -> 20*4*4=320
x = x.view(batch_size, -1) # 变成全连接网络想要的输入 batch*320
x = self.fc(x) # 全连接（用交叉熵损失，所以最后一层不用激活函数）
return x
model = Model()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # 使用GPU
model.to(device) # 转为CUDA tensor
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) # 冲量
# # step3 训练和测试
def train(epoch):
running_loss = 0.0
for batch_idx, data in enumerate(train_loader, 0):
inputs, target = data
inputs, target = inputs.to(device), target.to(device)
optimizer.zero_grad() # 优化器清零
outputs = model(inputs) # 前馈
loss = criterion(outputs, target)
loss.backward() # 反馈
optimizer.step() # 更新
running_loss += loss.item()
if batch_idx % 300 == 299: # 每300次输出一次loss
print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
running_loss = 0.0
def test():
correct = 0
total = 0
with torch.no_grad(): # 测试时候不需要梯度
for data in test_loader:
images, labels = data
images, labels = images.to(device), labels.to(device)
outputs = model(images) # 输出是一个矩阵 10列
_, predicted = torch.max(outputs.data, dim=1) # 取出每一行的最大值，对应分类，返回最大值和最大值的下标
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy on test set: %d %%' % (100 * correct / total))
if __name__ == '__main__':
for epoch in range(10):
train(epoch)
if epoch % 10 == 9:
test()
结果图
作业
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms
import torch.nn.functional as F # 激活函数relu
import torch.optim as optim
# # step1 准备数据集
batch_size = 64
transform = transforms.Compose([ # 将下列的内容构成pipline
transforms.ToTensor(), # 把原始数据转为张量 PIL图像0-255转为图像张量0-1
transforms.Normalize((0.1307, ), (0.3081, )) # 归一化 做normalization， 前为均值，后为标准差 数据标准化
])
train_dataset = datasets.MNIST(root='../dataset/mnist', train=True, download=False, transform=transform)
test_dataset = datasets.MNIST(root='../dataset/mnist', train=False, download=False, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
# # step2 设计模型
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1, 8, kernel_size=3, stride=1)
self.conv2 = nn.Conv2d(8, 16, kernel_size=3, stride=1)
self.conv3 = nn.Conv2d(16, 32, kernel_size=3, stride=1)
self.pool = nn.MaxPool2d(2)
self.fc1 = nn.Linear(32, 20)
self.fc2 = nn.Linear(20, 16)
self.fc3 = nn.Linear(16, 10)
def forward(self, x):
batch_size = x.size(0) # 1*28*28 样本数量
x = self.pool(F.relu(self.conv1(x))) # 8*13*13
x = self.pool(F.relu(self.conv2(x))) # 16*6*6
x = self.pool(F.relu(self.conv3(x))) # 32*2*2=128
x = x.view(batch_size, -1) # 变成全连接网络想要的输入 batch*320
x = self.fc1(x) # 全连接（用交叉熵损失，所以最后一层不用激活函数）
x = self.fc2(x)
x = self.fc3(x)
return x
model = Model()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # 使用GPU
model.to(device) # 转为CUDA tensor
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) # 冲量
# # step3 训练和测试
def train(epoch):
running_loss = 0.0
for batch_idx, data in enumerate(train_loader, 0):
inputs, target = data
inputs, target = inputs.to(device), target.to(device)
optimizer.zero_grad() # 优化器清零
outputs = model(inputs) # 前馈
loss = criterion(outputs, target)
loss.backward() # 反馈
optimizer.step() # 更新
running_loss += loss.item()
if batch_idx % 300 == 299: # 每300次输出一次loss
print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
running_loss = 0.0
def test():
correct = 0
total = 0
with torch.no_grad(): # 测试时候不需要梯度
for data in test_loader:
images, labels = data
images, labels = images.to(device), labels.to(device)
outputs = model(images) # 输出是一个矩阵 10列
_, predicted = torch.max(outputs.data, dim=1) # 取出每一行的最大值，对应分类，返回最大值和最大值的下标
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy on test set: %d %%' % (100 * correct / total))
if __name__ == '__main__':
for epoch in range(10):
train(epoch)
if epoch % 10 == 9:
test()
结果图
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
