Pytorch + Visdom CNN-Methode zur Verarbeitung selbst erstellter Bilddatensätze

Dieser Artikel stellt hauptsächlich die Methode von Pytorch + Visdom zur Verarbeitung selbst erstellter Bilddatensätze vor. Jetzt kann ich ihn mit Ihnen teilen

Umgebung

System: win10

CPU: i7-6700HQ

GPU: gtx965m

Python: 3.6

Pytorch: 0,3

Daten-Download

Quelle: Sasank Chilamkurthys Tutorial; Download-Link.

Nach dem Herunterladen entpacken und im Stammverzeichnis des Projekts ablegen:

Der Datensatz wird zur Klassifizierung verwendet Ameisen und Bienen. Für jede Klasse gibt es etwa 120 Trainingsbilder und 75 Validierungsbilder.

Datenimport

Sie können das Modul Torchvision.datasets.ImageFolder(root,transforms) verwenden, um Bilder in Tensoren zu konvertieren.

Erste Transformation definieren:

ata_transforms = {
  'train': transforms.Compose([
    # 随机切成224x224 大小图片 统一图片格式
    transforms.RandomResizedCrop(224),
    # 图像翻转
    transforms.RandomHorizontalFlip(),
    # totensor 归一化(0,255) >> (0,1)  normalize  channel=（channel-mean）/std
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
  ]),
  "val" : transforms.Compose([
    # 图片大小缩放 统一图片格式
    transforms.Resize(256),
    # 以中心裁剪
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
  ])
}

Daten importieren, laden:

data_dir = './hymenoptera_data'
# trans data
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'val']}
# load data
data_loaders = {x: DataLoader(image_datasets[x], batch_size=BATCH_SIZE, shuffle=True) for x in ['train', 'val']}

data_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes
print(data_sizes, class_names)

{'train': 244, 'val': 153} ['ants', 'bees']

Der Trainingssatz enthält 244 Bilder und der Testsatz 153 Bilder.

Schauen Sie sich den visuellen Teil des Bildes an. Da Visdom die Tensor-Eingabe unterstützt, müssen Sie diese nicht in Numpy ändern. Sie können die Tensor-Berechnung direkt verwenden:

inputs, classes = next(iter(data_loaders['val']))
out = torchvision.utils.make_grid(inputs)
inp = torch.transpose(out, 0, 2)
mean = torch.FloatTensor([0.485, 0.456, 0.406])
std = torch.FloatTensor([0.229, 0.224, 0.225])
inp = std * inp + mean
inp = torch.transpose(inp, 0, 2)
viz.images(inp)

CNN erstellen

net Basierend auf der Behandlung von cifar10 im vorherigen Artikel wurden die Spezifikationen geändert:

class CNN(nn.Module):
  def __init__(self, in_dim, n_class):
    super(CNN, self).__init__()
    self.cnn = nn.Sequential(
      nn.BatchNorm2d(in_dim),
      nn.ReLU(True),
      nn.Conv2d(in_dim, 16, 7), # 224 >> 218
      nn.BatchNorm2d(16),
      nn.ReLU(inplace=True),
      nn.MaxPool2d(2, 2), # 218 >> 109
      nn.ReLU(True),
      nn.Conv2d(16, 32, 5), # 105
      nn.BatchNorm2d(32),
      nn.ReLU(True),
      nn.Conv2d(32, 64, 5), # 101
      nn.BatchNorm2d(64),
      nn.ReLU(True),
      nn.Conv2d(64, 64, 3, 1, 1),
      nn.BatchNorm2d(64),
      nn.ReLU(True),
      nn.MaxPool2d(2, 2), # 101 >> 50
      nn.Conv2d(64, 128, 3, 1, 1), #
      nn.BatchNorm2d(128),
      nn.ReLU(True),
      nn.MaxPool2d(3), # 50 >> 16
    )
    self.fc = nn.Sequential(
      nn.Linear(128*16*16, 120),
      nn.BatchNorm1d(120),
      nn.ReLU(True),
      nn.Linear(120, n_class))
  def forward(self, x):
    out = self.cnn(x)
    out = self.fc(out.view(-1, 128*16*16))
    return out

# 输入3层rgb ，输出 分类 2    
model = CNN(3, 2)

Verlust, Optimierungsfunktion:

line = viz.line(Y=np.arange(10))
loss_f = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=LR, momentum=0.9)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)

Parameter:

BATCH_SIZE = 4
LR = 0.001
EPOCHS = 10

Führen Sie 10 Epochen aus und sehen Sie:

[9/10] train_loss:0.650|train_acc:0.639|test_loss:0.621|test_acc0.706
[10/10] train_loss:0.645|train_acc:0.627|test_loss:0.654|test_acc0.686
Training complete in 1m 16s
Best val Acc: 0.712418

Führen Sie 20 Epochen aus und sehen Sie:

[19/20] train_loss:0.592|train_acc:0.701|test_loss:0.563|test_acc0.712
[20/20] train_loss:0.564|train_acc:0.721|test_loss:0.571|test_acc0.706
Training complete in 2m 30s
Best val Acc: 0.745098

Die Genauigkeit ist relativ gering: Nur 74,5 %

Wir verwenden resnet18 in Modellen, um 10 Epochen auszuführen:

model = torchvision.models.resnet18(True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2)

rrree

Der Effekt ist auch Sehr durchschnittlich. Wir möchten die Modelle in kurzer Zeit mit guten Ergebnissen trainieren. Genauigkeit.

Verwandte Empfehlungen:

pytorch + Visdom behandelt einfache Klassifizierungsprobleme

Das obige ist der detaillierte Inhalt vonPytorch + Visdom CNN-Methode zur Verarbeitung selbst erstellter Bilddatensätze. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!