PyTorch 實戰(zhàn)之水果分類器

import osimport torchimport torchvisionimport tarfileimport torch.nn as nnimport numpy as npimport torch.nn.functional as Ffrom torchvision.datasets.utils import download_urlfrom torchvision.datasets import ImageFolderfrom torch.utils.data import DataLoaderfrom torchvision.transforms import ToTensorimport torchvision.transforms as ttfrom torch.utils.data import random_splitfrom torchvision.utils import make_gridimport matplotlibimport matplotlib.pyplot as plt%matplotlib inline
import warningswarnings.filterwarnings("ignore")

# Upload kaggle.jason# please follow this link incase not aware: https://www.kaggle.com/general/74235from google.colab import filesfiles.upload()
! pip install opendatasets --upgradeimport opendatasets as od
dataset_url = 'https://www.kaggle.com/moltean/fruits'od.download(dataset_url)

dataset_size = len(train_dataset)test_dataset_size = len(test_dataset)print(train_dataset)print(test_dataset)

Dataset ImageFolder    Number of datapoints: 67692    Root location: /content/fruits/fruits-360/Training    StandardTransformTransform: ToTensor()Dataset ImageFolder    Number of datapoints: 22688    Root location: /content/fruits/fruits-360/Test    StandardTransformTransform: ToTensor()

# Accesssing the classesdata_dir = '/content/fruits/fruits-360/'
# print(os.listdir(data_dir))classes = os.listdir(data_dir + "Training")print(f'Total Number of Classe {len(classes)}')print(f'Classes Names: {classes}')

Total Number of Classe 131Classes Names: ['Apple Braeburn', 'Cherry Wax Red', 'Melon Piel de Sapo', 'Rambutan', 'Tamarillo', 'Pepino', 'Lemon', 'Tomato Cherry Red', 'Apple Golden 1', 'Peach Flat', 'Apple Red Delicious', 'Lemon Meyer', 'Banana Red', 'Orange', 'Peach 2', 'Pepper Red', 'Grape White', 'Kaki', 'Pepper Yellow', 'Salak', 'Potato White', 'Cucumber Ripe 2', 'Apple Golden 2', 'Pitahaya Red', 'Mulberry', 'Carambula', 'Pear Abate', 'Banana', 'Tomato Maroon', 'Pear Red', 'Pear Forelle', 'Pineapple', 'Ginger Root', 'Potato Red', 'Apple Pink Lady', 'Pear Kaiser', 'Mandarine', 'Strawberry', 'Apple Golden 3', 'Nectarine', 'Plum 3', 'Avocado ripe', 'Cantaloupe 2', 'Fig', 'Tomato 1', 'Tomato Heart', 'Passion Fruit', 'Grape Blue', 'Cantaloupe 1', 'Apple Granny Smith', 'Banana Lady Finger', 'Mango Red', 'Cherry Rainier', 'Corn Husk', 'Hazelnut', 'Pear', 'Cauliflower', 'Pear Williams', 'Tangelo', 'Avocado', 'Physalis', 'Chestnut', 'Onion White', 'Granadilla', 'Strawberry Wedge', 'Plum 2', 'Plum', 'Pepper Green', 'Tomato 3', 'Grape White 4', 'Quince', 'Maracuja', 'Apple Red 1', 'Grapefruit White', 'Cherry 1', 'Walnut', 'Grape White 2', 'Cactus fruit', 'Grape Pink', 'Potato Red Washed', 'Apple Red Yellow 1', 'Cherry 2', 'Pear 2', 'Huckleberry', 'Guava', 'Apple Red 2', 'Beetroot', 'Limes', 'Kiwi', 'Tomato 2', 'Pear Stone', 'Grapefruit Pink', 'Peach', 'Mango', 'Nut Forest', 'Cherry Wax Yellow', 'Eggplant', 'Clementine', 'Pear Monster', 'Nectarine Flat', 'Pepper Orange', 'Onion Red Peeled', 'Cocos', 'Grape White 3', 'Redcurrant', 'Dates', 'Tomato Yellow', 'Pomegranate', 'Pineapple Mini', 'Pomelo Sweetie', 'Papaya', 'Corn', 'Cucumber Ripe', 'Onion Red', 'Nut Pecan', 'Potato Sweet', 'Cherry Wax Black', 'Physalis with Husk', 'Mangostan', 'Tomato not Ripened', 'Tomato 4', 'Apricot', 'Kumquats', 'Apple Red Yellow 2', 'Kohlrabi', 'Lychee', 'Apple Crimson Snow', 'Blueberry', 'Raspberry', 'Watermelon', 'Apple Red 3']

img, label = train_dataset[0]img_shape = img.shapeimg_shape

torch.Size([3, 100, 100])

img, label = train_dataset[0]plt.imshow(img.permute((1, 2, 0)))print('Label (numeric):', label)print('Label (textual):', classes[label])

dataset_size = len(train_dataset)classes = train_dataset.classesnum_classes = len(train_dataset.classes)
img_dict = {}for i in range(num_classes):    img_dict[classes[i]] = 0    for i in range(dataset_size):    img, label = train_dataset[i]    img_dict[classes[label]] += 1

## Plotting classes along with images info
from matplotlib import pyplot as plt
fig, ax = plt.subplots(figsize =(16, 32))
ax.barh(list(img_dict.keys()), list(img_dict.values()))


# Add Plot Titleax.set_title('Each Class along with their values',             loc ='left', )
# Add annotation to barsfor i in ax.patches:    plt.text(i.get_width()+0.2, i.get_y()+0.5,             str(round((i.get_width()), 2)),             fontsize = 10, fontweight ='bold',             color ='grey')
# Add Text watermarkfig.text(0.9, 0.15, 'gurjeet333', fontsize = 12,         color ='grey', ha ='right', va ='bottom',         alpha = 0.7)plt.show()

# Data transforms (data augmentation)train_tfms = tt.Compose([                         tt.RandomCrop(100, padding=4, padding_mode='reflect'),                          tt.Resize((100,100)),                         tt.RandomHorizontalFlip(),                          # tt.RandomRotate                         # tt.RandomResizedCrop(256, scale=(0.5,0.9), ratio=(1, 1)),                          # tt.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),                         tt.ToTensor(), 
                         ])valid_tfms = tt.Compose([tt.ToTensor(), tt.Resize((100,100)),                         ])

dataset = ImageFolder(data_dir + "/Training", transform=train_tfms)
Testing = ImageFolder(data_dir + "/Test", transform=valid_tfms)

torch.manual_seed(43)val_size = round(len(dataset) * 0.2)train_size = round(len(dataset) - val_size)
train_ds, val_ds = random_split(dataset, [train_size, val_size])len(train_ds), len(val_ds)

batch_size=400
train_loader = DataLoader(train_ds, batch_size, shuffle=True, num_workers=4, pin_memory=True)val_loader = DataLoader(val_ds, batch_size*2, num_workers=4, pin_memory=True)test_loader = DataLoader(test_dataset, batch_size*2, num_workers=4, pin_memory=True)

def show_batch(dl):    for images, labels in dl:        fig, ax = plt.subplots(figsize=(12, 12))        ax.set_xticks([]); ax.set_yticks([])        ax.imshow(make_grid(images, nrow=16).permute(1, 2, 0))        break
show_batch(train_loader)

def get_default_device():    """Pick GPU if available, else CPU"""    if torch.cuda.is_available():        return torch.device('cuda')    else:        return torch.device('cpu')    def to_device(data, device):    """Move tensor(s) to chosen device"""    if isinstance(data, (list,tuple)):        return [to_device(x, device) for x in data]    return data.to(device, non_blocking=True)
class DeviceDataLoader():    """Wrap a dataloader to move data to a device"""    def __init__(self, dl, device):        self.dl = dl        self.device = device            def __iter__(self):        """Yield a batch of data after moving it to device"""        for b in self.dl:             yield to_device(b, self.device)
    def __len__(self):        """Number of batches"""        return len(self.dl)

device = get_default_device()device
train_dl = DeviceDataLoader(train_loader, device)valid_dl = DeviceDataLoader(val_loader, device)

def accuracy(outputs, labels):    _, preds = torch.max(outputs, dim=1)    return torch.tensor(torch.sum(preds == labels).item() / len(preds))

class ImageClassificationBase(nn.Module):    def training_step(self, batch):        images, labels = batch         out = self(images)                  # Generate predictions        loss = F.cross_entropy(out, labels) # Calculate loss        return loss        def validation_step(self, batch):        images, labels = batch         out = self(images)                    # Generate predictions        loss = F.cross_entropy(out, labels)   # Calculate loss        acc = accuracy(out, labels)           # Calculate accuracy        return {'val_loss': loss.detach(), 'val_acc': acc}            def validation_epoch_end(self, outputs):        batch_losses = [x['val_loss'] for x in outputs]        epoch_loss = torch.stack(batch_losses).mean()   # Combine losses        batch_accs = [x['val_acc'] for x in outputs]        epoch_acc = torch.stack(batch_accs).mean()      # Combine accuracies        return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}        def epoch_end(self, epoch, result):        print("Epoch [{}], train_loss: {:.4f}, val_loss: {:.4f}, val_acc: {:.4f}".format(epoch, result['train_loss'], result['val_loss'], result['val_acc']))

class ImageClassificationBase(nn.Module):    def training_step(self, batch):        images, labels = batch         out = self(images)                  # Generate predictions        loss = F.cross_entropy(out, labels) # Calculate loss        return loss        def validation_step(self, batch):        images, labels = batch         out = self(images)                    # Generate predictions        loss = F.cross_entropy(out, labels)   # Calculate loss        acc = accuracy(out, labels)           # Calculate accuracy        return {'val_loss': loss.detach(), 'val_acc': acc}            def validation_epoch_end(self, outputs):        batch_losses = [x['val_loss'] for x in outputs]        epoch_loss = torch.stack(batch_losses).mean()   # Combine losses        batch_accs = [x['val_acc'] for x in outputs]        epoch_acc = torch.stack(batch_accs).mean()      # Combine accuracies        return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}        def epoch_end(self, epoch, result):        print("Epoch [{}], train_loss: {:.4f}, val_loss: {:.4f}, val_acc: {:.4f}".format(epoch, result['train_loss'], result['val_loss'], result['val_acc']))

class Fruit360CnnModel(ImageClassificationBase):    def __init__(self):        super().__init__()        self.network = nn.Sequential(                        nn.Conv2d(3, 16, kernel_size=2, padding=1),             nn.BatchNorm2d(16),            nn.ReLU(),            nn.MaxPool2d(2, 2), # 16 X 50 X 50
            nn.Conv2d(16, 32, kernel_size=2, stride=1, padding=1),             nn.BatchNorm2d(32),            nn.ReLU(),            nn.MaxPool2d(2, 2), # 32 X 25 X 25
            nn.Conv2d(32, 64, kernel_size=2, stride=1, padding=1),            nn.BatchNorm2d(64),            nn.ReLU(),            nn.MaxPool2d(5, 5), # 64 X 5 X 5
            nn.Flatten(),             nn.Dropout(0.3),            nn.ReLU(),            nn.Linear(64*5*5, 131))            def forward(self, xb):      return self.network(xb)
model = Fruit360CnnModel()model

Fruit360CnnModel(  (network): Sequential(    (0): Conv2d(3, 16, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))    (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)    (2): ReLU()    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)    (4): Conv2d(16, 32, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))    (5): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)    (6): ReLU()    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)    (8): Conv2d(32, 64, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))    (9): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)    (10): ReLU()    (11): MaxPool2d(kernel_size=5, stride=5, padding=0, dilation=1, ceil_mode=False)    (12): Flatten(start_dim=1, end_dim=-1)    (13): Dropout(p=0.3, inplace=False)    (14): ReLU()    (15): Linear(in_features=1600, out_features=131, bias=True)  ))

@torch.no_grad()
def evaluate(model, val_loader):    model.eval()    outputs = [model.validation_step(batch) for batch in val_loader]    return model.validation_epoch_end(outputs)
def get_lr(optimizer):    for param_group in optimizer.param_groups:        return param_group['lr']
def fit_one_cycle(epochs, max_lr, model, train_loader, val_loader,                   weight_decay=0, grad_clip=None, opt_func=torch.optim.SGD):    torch.cuda.empty_cache()    history = []        # Set up cutom optimizer with weight decay    optimizer = opt_func(model.parameters(), max_lr, weight_decay=weight_decay)    # Set up one-cycle learning rate scheduler    sched = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr, epochs=epochs,                                                 steps_per_epoch=len(train_loader))    for epoch in range(epochs):        # Training Phase         model.train()        train_losses = []        lrs = []        for batch in train_loader:            loss = model.training_step(batch)            train_losses.append(loss)            loss.backward()                        # Gradient clipping            if grad_clip:                 nn.utils.clip_grad_value_(model.parameters(), grad_clip)                        optimizer.step()            optimizer.zero_grad()                        # Record & update learning rate            lrs.append(get_lr(optimizer))            sched.step()                # Validation phase        result = evaluate(model, val_loader)        result['train_loss'] = torch.stack(train_losses).mean().item()        result['lrs'] = lrs        model.epoch_end(epoch, result)        history.append(result)    return history

# Moving the model to GPUmodel = to_device(model, device)model

Fruit360CnnModel(  (network): Sequential(    (0): Conv2d(3, 16, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))    (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)    (2): ReLU()    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)    (4): Conv2d(16, 32, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))    (5): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)    (6): ReLU()    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)    (8): Conv2d(32, 64, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))    (9): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)    (10): ReLU()    (11): MaxPool2d(kernel_size=5, stride=5, padding=0, dilation=1, ceil_mode=False)    (12): Flatten(start_dim=1, end_dim=-1)    (13): Dropout(p=0.3, inplace=False)    (14): ReLU()    (15): Linear(in_features=1600, out_features=131, bias=True)  ))

os.environ['WANDB_CONSOLE'] = 'off'
history = [evaluate(model, valid_dl)]history

[{'val_acc': 0.005484417546540499, 'val_loss': 4.877397537231445}]

epochs = 4max_lr = 0.01grad_clip = 0.1weight_decay = 1e-4opt_func = torch.optim.Adam

%%time
os.environ['WANDB_CONSOLE'] = 'off'
history += fit_one_cycle(epochs, max_lr, model, train_dl, valid_dl,                              grad_clip=grad_clip,                              weight_decay=weight_decay,                              opt_func=opt_func)

Epoch [0], train_loss: 1.2414, val_loss: 0.8754, val_acc: 0.7948Epoch [1], train_loss: 0.1211, val_loss: 0.0212, val_acc: 0.9931Epoch [2], train_loss: 0.0101, val_loss: 0.0025, val_acc: 0.9996Epoch [3], train_loss: 0.0049, val_loss: 0.0011, val_acc: 0.9999CPU times: user 11.8 s, sys: 7.95 s, total: 19.8 sWall time: 3min 7

def plot_accuracies(history):    accuracies = [x['val_acc'] for x in history]    plt.plot(accuracies, '-x')    plt.xlabel('epoch')    plt.ylabel('accuracy')    plt.title('Accuracy vs. No. of epochs');
plot_accuracies(history)

def plot_losses(history):    train_losses = [x.get('train_loss') for x in history]    val_losses = [x['val_loss'] for x in history]    plt.plot(train_losses, '-bx')    plt.plot(val_losses, '-rx')    plt.xlabel('epoch')    plt.ylabel('loss')    plt.legend(['Training', 'Validation'])    plt.title('Loss vs. No. of epochs');
plot_losses(history)

def plot_lrs(history):    lrs = np.concatenate([x.get('lrs', []) for x in history])    plt.plot(lrs)    plt.xlabel('Batch no.')    plt.ylabel('Learning rate')    plt.title('Learning Rate vs. Batch no.');

test_tfms = tt.Compose([tt.Resize((100, 100)),                         tt.ToTensor()])test_dataset = ImageFolder(data_dir + "Test", transform=test_tfms)test_loader = DeviceDataLoader(DataLoader(test_dataset, batch_size), device)result = evaluate(model, test_loader)result

{'val_acc': 0.9883334040641785, 'val_loss': 0.08684124052524567}

def predict_image(img, model):    # Convert to a batch of 1    xb = to_device(img.unsqueeze(0), device)    # Get predictions from model    yb = model(xb)    # Pick index with highest probability    _, preds  = torch.max(yb, dim=1)    # Retrieve the class label    return dataset.classes[preds[0].item()]

img, label = test_dataset[0]plt.imshow(img.permute(1, 2, 0))print('Label:', dataset.classes[label], 'Predicted:', predict_image(img, model))