Hoşgeldin Misafir

Bilgisayarla Görme

Mustafa73

Mustafa73

Mustafa73

20 Eyl 2023
423 Mesaj

Aktiflik

Seviye

Deneyim

TIM / GÖREV:
Merhaba ben Mustafa73 Lojistik Tim adına paylaşım yapıyorum. BERT İnce Ayarı ve Uygulamaları makalesinde sizi görmekten mutluyum.
İmge Artırma
Bilgisayarla görme alanında "imge artırma" (image augmentation), eğitim imgelerine bir dizi rastgele değişiklik uygulanarak yeni ve farklı eğitim örnekleri üretme sürecidir. Bu yöntem, eğitim veri kümesinin boyutunu artırır ve modelin genelleme yeteneğini geliştirir. Modelin belirli niteliklere olan bağımlılığını azaltmak için de kullanılabilir. Örneğin, imgeyi farklı şekillerde kırparak nesnenin farklı pozisyonlarda görünmesini sağlarız, böylece model nesnenin konumuna daha az bağımlı olur. Benzer şekilde, parlaklık ve renk gibi faktörleri ayarlayarak modelin renge duyarlılığını azaltabiliriz. AlexNet'in başarısında imge artırmanın önemli bir rol oynadığı düşünülmektedir.
Aşağıda, yaygın imge artırma yöntemlerini incelemek için bir Python kodu örneği verilmiştir:
Python: 
%matplotlib inline
import torch
import torchvision
from torch import nn
from d2l import torch as d2l
from PIL import Image

# İmgeyi yükle
img = Image.open('../img/cat1.jpg')
d2l.set_figsize()
d2l.plt.imshow(img)

# Yardımcı fonksiyon
def apply(img, aug, num_rows=2, num_cols=4, scale=1.5):
    Y = [aug(img) for _ in range(num_rows * num_cols)]
    d2l.show_images(Y, num_rows, num_cols, scale=scale)

# Yatay döndürme
apply(img, torchvision.transforms.RandomHorizontalFlip())

# Dikey döndürme
apply(img, torchvision.transforms.RandomVerticalFlip())

# Rastgele kırpma
shape_aug = torchvision.transforms.RandomResizedCrop(
    (200, 200), scale=(0.1, 1), ratio=(0.5, 2))
apply(img, shape_aug)

# Parlaklık değişimi
apply(img, torchvision.transforms.ColorJitter(
    brightness=0.5, contrast=0, saturation=0, hue=0))

# Birden fazla imge artırma yöntemi kombinasyonu
color_aug = torchvision.transforms.ColorJitter(
    brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5)
augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomHorizontalFlip(), color_aug, shape_aug])
apply(img, augs)
Bu kodda, farklı imge artırma tekniklerini tek tek ve birleştirerek uyguladık. Şimdi bu teknikleri kullanarak bir modelin nasıl eğitileceğini göstereceğiz.

İmge Artırması ile Model Eğitimi

CIFAR-10 veri kümesi kullanarak imge artırması ile bir modeli eğitmek için aşağıdaki adımları izleyebiliriz:

1. Eğitim ve test veri kümesi tanımlamaları:

Python: 
train_augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomHorizontalFlip(),
    torchvision.transforms.ToTensor()])
test_augs = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()])

2. Veri yükleyici fonksiyonları:

Python: 
def load_cifar10(is_train, augs, batch_size):
    dataset = torchvision.datasets.CIFAR10(root="../data", train=is_train,
                                           transform=augs, download=True)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,
                                             shuffle=is_train, num_workers=4)
    return dataloader

3. Eğitim fonksiyonları:
Python: 
def train_batch(net, X, y, loss, trainer, devices):
    if isinstance(X, list):
        X = [x.to(devices[0]) for x in X]
    else:
        X = X.to(devices[0])
    y = y.to(devices[0])
    net.train()
    trainer.zero_grad()
    pred = net(X)
    l = loss(pred, y)
    l.sum().backward()
    trainer.step()
    train_loss_sum = l.sum()
    train_acc_sum = (pred.argmax(dim=1) == y).sum()
    return train_loss_sum, train_acc_sum

def train(net, train_iter, test_iter, loss, trainer, num_epochs, devices):
    for epoch in range(num_epochs):
        metric = d2l.Accumulator(3)
        for i, (features, labels) in enumerate(train_iter):
            l, acc = train_batch(net, features, labels, loss, trainer, devices)
            metric.add(l, acc, labels.shape[0])
        print(f'epoch {epoch + 1}, loss {metric[0] / metric[2]:.3f}, '
              f'train acc {metric[1] / metric[2]:.3f}')
    test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)
    print(f'test acc {test_acc:.3f}')

4. Model eğitimi:

Python: 
batch_size, devices, net = 256, [torch.device('cuda' if torch.cuda.is_available() else 'cpu')], d2l.resnet18(10, 3)

def init_weights(m):
    if type(m) in [nn.Linear, nn.Conv2d]:
        nn.init.xavier_uniform_(m.weight)

net.apply(init_weights)

def train_with_data_aug(train_augs, test_augs, net, lr=0.001):
    train_iter = load_cifar10(True, train_augs, batch_size)
    test_iter = load_cifar10(False, test_augs, batch_size)
    loss = nn.CrossEntropyLoss(reduction="none")
    trainer = torch.optim.Adam(net.parameters(), lr=lr)
    train(net, train_iter, test_iter, loss, trainer, 10, devices)

train_with_data_aug(train_augs, test_augs, net)

Bu adımlar, CIFAR-10 veri kümesi kullanarak imge artırması ile bir modeli eğitmek için gerekli tüm kodları içerir. Model eğitildikten sonra, test verisi üzerinde performansını değerlendiririz.

İnce Ayar (Fine-tuning)

İnce ayar, daha önce büyük bir veri kümesi üzerinde önceden eğitilmiş bir modelin, daha küçük ve özel bir veri kümesine uyarlanması sürecidir. Bu, modelin genelleme yeteneğini artırır ve yeni veri kümesi üzerinde daha iyi performans göstermesini sağlar.

1. Veri kümesini okuma:

Python: 
data_dir = d2l.download_extract('hotdog')
train_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'))
test_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'))

2. İmge artırma işlemleri:

Python: 
normalize = torchvision.transforms.Normalize(
    [0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
train_augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomResizedCrop(224),
    torchvision.transforms.RandomHorizontalFlip(),
    torchvision.transforms.ToTensor(),
    normalize])
test_augs = torchvision.transforms.Compose([
    torchvision.transforms.Resize(256),
    torchvision.transforms.CenterCrop(224),
    torchvision.transforms.ToTensor(),
    normalize])

3. Modelin tanımlanması ve ince ayarlanması:
Python: 
pretrained_net = torchvision.models.resnet18(pretrained=True)
finetune_net = torchvision.models.resnet18(pretrained=True)
finetune_net.fc = nn.Linear(finetune_net.fc.in_features, 2)
nn.init.xavier_uniform_(finetune_net.fc.weight)

def train_fine_tuning(net, learning_rate, batch_size=128, num_epochs=5, param_group=True):
    train_iter = torch.utils.data.DataLoader(
        torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'), transform=train_augs),
        batch_size=batch_size, shuffle=True)
    test_iter = torch.utils.data.DataLoader(
        torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'), transform=test_augs),
        batch_size=batch_size)
    devices = [torch.device('cuda' if torch.cuda.is_available() else 'cpu')]
    loss = nn.CrossEntropyLoss(reduction="none")
    if param_group:
        params_1x = [param for name, param in net.named_parameters() if name not in ["fc.weight", "fc.bias"]]
        trainer = torch.optim.SGD([
            {'params': params_1x},
            {'params': net.fc.parameters(), 'lr': learning_rate * 10}
        ], lr=learning_rate, weight_decay=0.001)
    else:
        trainer = torch.optim.SGD(net.parameters(), lr=learning_rate, weight_decay=0.001)
    d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs, devices)

train_fine_tuning(finetune_net, 0.001)


Bu kod örneği, sosisli sandviç tanıma problemi üzerinde ince ayar uygulayarak, ImageNet veri kümesi üzerinde önceden eğitilmiş bir ResNet-18 modelini kullanarak gerçekleştirilmiştir. Bu süreç, modelin genelleme yeteneğini artırmak ve yeni veri kümesine uyum sağlamasını sağlamak için etkili bir yöntemdir.
 
Cevap yazmak için giriş yap yada kayıt ol.
Geri
Üst