pytoch VGG 11は、cifar 10データセットを識別する(トレーニング+予測単一入力ピクチャ操作)
まずこれはVGGの構造図で、VGG 11は赤い枠の中の構造で、全部で5つのブロックに分けられています。例えば、赤枠の中のVGG 11の最初のblockは一つのconv 3-64畳込み層です。
一、VGGコードを書く時、まず一つのvgg_を定義します。block(n,in,out)方法は、VGGの各blockにおける畳み込み核と池化層を構築するために使用される。
nはこのblockのボリューム層の数であり、nは入力チャネル数であり、outは出力チャネル数である。
blockがあったら、形成されたblockを畳む方法が必要です。私達はこの方法をvgg_と定義します。ロック:
vgg_net=vgg_(1,1,2,2,2),(3,64),(64,128),(128,256),(256,512)))
ここで、(1,1,2,2)は5つのblockのうち、それぞれの畳み込み層数を表し、(3,64)、(64,128)、(128,256)、(256,512,512)は各blockの畳み込み層の種類を表し、(3,64)はこのボリューム入力チャネル数が3であり、出力チャネル数が64であることを示しています。vgg_stack方法は完全なvg 11モデルに戻ります。
次に、vgg類を定義し、vgg_を含む。stack方法:
net=vgg()菗はvggネットワークにアクセスできます。
では、vggネットワークの完全なpytochコードを構築すると:
二、ネットで画像を探して、32 x 32に縮小して、予測コードの中に入れば、予測結果が現れます。予測コードは下記の通りです。
実行結果:
以上のpytouch VGG 11はcifar 10データセット(訓練+予測シート入力画像操作)を識別しました。つまり、小編集は皆さんに共有した内容の全部です。参考にしてもらいたいです。どうぞよろしくお願いします。
一、VGGコードを書く時、まず一つのvgg_を定義します。block(n,in,out)方法は、VGGの各blockにおける畳み込み核と池化層を構築するために使用される。
nはこのblockのボリューム層の数であり、nは入力チャネル数であり、outは出力チャネル数である。
blockがあったら、形成されたblockを畳む方法が必要です。私達はこの方法をvgg_と定義します。ロック:
def vgg_stack(num_convs, channels): # vgg_net = vgg_stack((1, 1, 2, 2, 2), ((3, 64), (64, 128), (128, 256), (256, 512), (512, 512)))
net = []
for n, c in zip(num_convs, channels):
in_c = c[0]
out_c = c[1]
net.append(vgg_block(n, in_c, out_c))
return nn.Sequential(*net)
右のコメントvgg_net=vgg_(1,1,2,2,2),(3,64),(64,128),(128,256),(256,512)))
ここで、(1,1,2,2)は5つのblockのうち、それぞれの畳み込み層数を表し、(3,64)、(64,128)、(128,256)、(256,512,512)は各blockの畳み込み層の種類を表し、(3,64)はこのボリューム入力チャネル数が3であり、出力チャネル数が64であることを示しています。vgg_stack方法は完全なvg 11モデルに戻ります。
次に、vgg類を定義し、vgg_を含む。stack方法:
#vgg
class vgg(nn.Module):
def __init__(self):
super(vgg, self).__init__()
self.feature = vgg_net
self.fc = nn.Sequential(
nn.Linear(512, 100),
nn.ReLU(True),
nn.Linear(100, 10)
)
def forward(self, x):
x = self.feature(x)
x = x.view(x.shape[0], -1)
x = self.fc(x)
return x
最後:net=vgg()菗はvggネットワークにアクセスできます。
では、vggネットワークの完全なpytochコードを構築すると:
def vgg_block(num_convs, in_channels, out_channels):
net = [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(True)]
for i in range(num_convs - 1): #
net.append(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1))
net.append(nn.ReLU(True))
net.append(nn.MaxPool2d(2, 2)) #
return nn.Sequential(*net)
# vgg block
def vgg_stack(num_convs, channels): # vgg_net = vgg_stack((1, 1, 2, 2, 2), ((3, 64), (64, 128), (128, 256), (256, 512), (512, 512)))
net = []
for n, c in zip(num_convs, channels):
in_c = c[0]
out_c = c[1]
net.append(vgg_block(n, in_c, out_c))
return nn.Sequential(*net)
# vgg , vgg11 vgg16 vgg19
vgg_net = vgg_stack((1, 1, 2, 2, 2), ((3, 64), (64, 128), (128, 256), (256, 512), (512, 512)))
#vgg
class vgg(nn.Module):
def __init__(self):
super(vgg, self).__init__()
self.feature = vgg_net
self.fc = nn.Sequential(
nn.Linear(512, 100),
nn.ReLU(True),
nn.Linear(100, 10)
)
def forward(self, x):
x = self.feature(x)
x = x.view(x.shape[0], -1)
x = self.fc(x)
return x
# vgg
net = vgg()
VGG 11に基づくcifar 10トレーニングコード:
import sys
import numpy as np
import torch
from torch import nn
from torch.autograd import Variable
from torchvision.datasets import CIFAR10
import torchvision.transforms as transforms
def vgg_block(num_convs, in_channels, out_channels):
net = [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(True)]
for i in range(num_convs - 1): #
net.append(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1))
net.append(nn.ReLU(True))
net.append(nn.MaxPool2d(2, 2)) #
return nn.Sequential(*net)
# vgg block
def vgg_stack(num_convs, channels): # vgg_net = vgg_stack((1, 1, 2, 2, 2), ((3, 64), (64, 128), (128, 256), (256, 512), (512, 512)))
net = []
for n, c in zip(num_convs, channels):
in_c = c[0]
out_c = c[1]
net.append(vgg_block(n, in_c, out_c))
return nn.Sequential(*net)
#vgg
class vgg(nn.Module):
def __init__(self):
super(vgg, self).__init__()
self.feature = vgg_net
self.fc = nn.Sequential(
nn.Linear(512, 100),
nn.ReLU(True),
nn.Linear(100, 10)
)
def forward(self, x):
x = self.feature(x)
x = x.view(x.shape[0], -1)
x = self.fc(x)
return x
# cifar10
def data_tf(x):
x = np.array(x, dtype='float32') / 255
x = (x - 0.5) / 0.5
x = x.transpose((2, 0, 1)) ## channel , pytorch
x = torch.from_numpy(x)
return x
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)),
])
def get_acc(output, label):
total = output.shape[0]
_, pred_label = output.max(1)
num_correct = (pred_label == label).sum().item()
return num_correct / total
def train(net, train_data, valid_data, num_epochs, optimizer, criterion):
if torch.cuda.is_available():
net = net.cuda()
for epoch in range(num_epochs):
train_loss = 0
train_acc = 0
net = net.train()
for im, label in train_data:
if torch.cuda.is_available():
im = Variable(im.cuda())
label = Variable(label.cuda())
else:
im = Variable(im)
label = Variable(label)
# forward
output = net(im)
loss = criterion(output, label)
# forward
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_loss += loss.item()
train_acc += get_acc(output, label)
if valid_data is not None:
valid_loss = 0
valid_acc = 0
net = net.eval()
for im, label in valid_data:
if torch.cuda.is_available():
with torch.no_grad():
im = Variable(im.cuda())
label = Variable(label.cuda())
else:
with torch.no_grad():
im = Variable(im)
label = Variable(label)
output = net(im)
loss = criterion(output, label)
valid_loss += loss.item()
valid_acc += get_acc(output, label)
epoch_str = (
"Epoch %d. Train Loss: %f, Train Acc: %f, Valid Loss: %f, Valid Acc: %f, "
% (epoch, train_loss / len(train_data),
train_acc / len(train_data), valid_loss / len(valid_data),
valid_acc / len(valid_data)))
else:
epoch_str = ("Epoch %d. Train Loss: %f, Train Acc: %f, " %
(epoch, train_loss / len(train_data),
train_acc / len(train_data)))
# prev_time = cur_time
print(epoch_str)
if __name__ == '__main__':
# , vgg11 , 8
vgg_net = vgg_stack((1, 1, 2, 2, 2), ((3, 64), (64, 128), (128, 256), (256, 512), (512, 512)))
print(vgg_net)
train_set = CIFAR10('./data', train=True, transform=transform, download=True)
train_data = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
test_set = CIFAR10('./data', train=False, transform=transform, download=True)
test_data = torch.utils.data.DataLoader(test_set, batch_size=128, shuffle=False)
net = vgg()
optimizer = torch.optim.SGD(net.parameters(), lr=1e-1)
criterion = nn.CrossEntropyLoss() #
train(net, train_data, test_data, 50, optimizer, criterion)
torch.save(net, 'vgg_model.pth')
終了後、モデルファイルが出現します。model.pth二、ネットで画像を探して、32 x 32に縮小して、予測コードの中に入れば、予測結果が現れます。予測コードは下記の通りです。
import torch
import cv2
import torch.nn.functional as F
from vgg2 import vgg ## , ( ), ,
from torch.autograd import Variable
from torchvision import datasets, transforms
import numpy as np
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
if __name__ == '__main__':
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = torch.load('vgg_model.pth') #
model = model.to(device)
model.eval() # test
img = cv2.imread("horse.jpg") #
trans = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
img = trans(img)
img = img.to(device)
img = img.unsqueeze(0) # , 4 [batch_size, , , ], ,[ , , ]
# , [1,1,28,28]
output = model(img)
prob = F.softmax(output,dim=1) #prob 10
print(prob)
value, predicted = torch.max(output.data, 1)
print(predicted.item())
print(value)
pred_class = classes[predicted.item()]
print(pred_class)
# prob = F.softmax(output, dim=1)
# prob = Variable(prob)
# prob = prob.cpu().numpy() # GPU gpu , cpu, numpy
# print(prob) # prob 10
# pred = np.argmax(prob) #
# # print(pred)
# # print(pred.item())
# pred_class = classes[pred]
# print(pred_class)
32 x 32に縮小された画像:実行結果:
以上のpytouch VGG 11はcifar 10データセット(訓練+予測シート入力画像操作)を識別しました。つまり、小編集は皆さんに共有した内容の全部です。参考にしてもらいたいです。どうぞよろしくお願いします。