/kaggle/input/ml2020spring-hw3/food-11/validation/8_8.jpg

/kaggle/input/ml2020spring-hw3/food-11/training/10_170.jpg

/kaggle/input/ml2020spring-hw3/food-11/testing/0664.jpg

import os

# import numpy as np

import cv2

import torch

import torch.nn as nn

import torchvision.transforms as transforms

# import pandas as pd

from torch.utils.data import DataLoader, Dataset

import time

for i, file in enumerate(image_dir):#遍历文件列表中文件名

        img = cv2.imread(os.path.join(path, file))#cv2读入原图片

        x[i, :, :] = cv2.resize(img,(128, 128))#对图片进行缩放, 存储到x的第i个中

        if label:

          y[i] = int(file.split("_")[0])#取出文件名中的类别信息

train_x, train_y = readfile(os.path.join(workspace_dir, "training"), True)

print("Size of training data = {}".format(len(train_x)))

# 训练时做数据增强(data augmentation)

train_transform = transforms.Compose([

    transforms.ToPILImage(),

    transforms.RandomHorizontalFlip(), # 随机将图片水平翻转

    transforms.RandomRotation(15), # 随机选择图片

    transforms.ToTensor(), # 图片转化为张量Tensor，並把數值 normalize 到 [0,1] (data normalization)

])

# 测试时不需做数据增强

test_transform = transforms.Compose([

    transforms.ToPILImage(),                                   

    transforms.ToTensor(),

])

# 将tensor转换为numpy

x_numpy = x_tensor.numpy()   #维度也不改变(1, 128, 228)

# numpy to PIL

x_pil = T.ToPILImage()(np.uint8(x))   #注意这里的np.uint8()，为了使其满足类型需求，在这里是必须的

# tensor to PIL

x = x.float()   # 有时候从numpy到tensor后再转化为PIL会报错，这一步就是使其满足数据类型

x_pil = T.ToPILImage()(x)

class ImgDataset(Dataset):

    #初始化中把所有传入内容赋给属性

    def __init__(self, x, y=None, transform=None):#如果没有传入y, transform, 则默认值为0

        self.x = x

        # label类型应为 LongTensor

        self.y = y

        if y is not None:

            self.y = torch.LongTensor(y)

        self.transform = transform

    # 返回dataset的大小

    def __len__(self):

        return len(self.x)

    # 用[ ]取值時，dataset如何返回. 返回前先对x进行转换

    def __getitem__(self, index):

        X = self.x[index]

        if self.transform is not None:

            X = self.transform(X)

        if self.y is not None:

            Y = self.y[index]

            return X, Y

        else:

            return X

batch_size = 128

train_set = ImgDataset(train_x, train_y, train_transform)

val_set = ImgDataset(val_x, val_y, test_transform)

train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)

val_loader = DataLoader(val_set, batch_size=batch_size, shuffle=False)

class Classifier(nn.Module):

    def __init__(self):

        super(Classifier, self).__init__()

        # torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)

        # torch.nn.MaxPool2d(kernel_size, stride, padding)

        # input 維度 [3, 128, 128]

        #cnn网络

        self.cnn = nn.Sequential(

            nn.Conv2d(3, 64, 3, 1, 1),  # [64, 128, 128]

            nn.BatchNorm2d(64),

            nn.ReLU(),

            nn.MaxPool2d(2, 2, 0),      # [64, 64, 64]

            nn.Conv2d(64, 128, 3, 1, 1), # [128, 64, 64]

            nn.BatchNorm2d(128),

            nn.ReLU(),

            nn.MaxPool2d(2, 2, 0),      # [128, 32, 32]

            nn.Conv2d(128, 256, 3, 1, 1), # [256, 32, 32]

            nn.BatchNorm2d(256),

            nn.ReLU(),

            nn.MaxPool2d(2, 2, 0),      # [256, 16, 16]

            nn.Conv2d(256, 512, 3, 1, 1), # [512, 16, 16]

            nn.BatchNorm2d(512),

            nn.ReLU(),

            nn.MaxPool2d(2, 2, 0),       # [512, 8, 8]

            nn.Conv2d(512, 512, 3, 1, 1), # [512, 8, 8]

            nn.BatchNorm2d(512),

            nn.ReLU(),

            nn.MaxPool2d(2, 2, 0),       # [512, 4, 4]

        )

        #全连接分类器

        self.fc = nn.Sequential(

            nn.Linear(512*4*4, 1024),

            nn.ReLU(),

            nn.Linear(1024, 512),

            nn.ReLU(),

            nn.Linear(512, 11)

        )

    def forward(self, x):

        out = self.cnn(x)

        out = out.view(out.size()[0], -1)

        return self.fc(out)

model = Classifier().cuda()#操作放在GPU

loss = nn.CrossEntropyLoss() # 分类任务的loss 使用 CrossEntropyLoss

optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # optimizer 使用 Adam

num_epoch = 30

for epoch in range(num_epoch):

    epoch_start_time = time.time()

    train_acc = 0.0#训练

    train_loss = 0.0

    val_acc = 0.0#验证

    val_loss = 0.0

    model.train() # 在训练时启用batch normalization和drop out(测试时操作不同)

    for i, data in enumerate(train_loader):

        optimizer.zero_grad() # 用 optimizer 將 model 參數的 gradient 歸零

        train_pred = model(data[0].cuda()) # 利用 model 得到預測的機率分佈 這邊實際上就是去呼叫 model 的 forward 函數

        batch_loss = loss(train_pred, data[1].cuda()) # 計算 loss （注意 prediction 跟 label 必須同時在 CPU 或是 GPU 上）

        batch_loss.backward() # 利用 back propagation 算出每個參數的 gradient

        optimizer.step() # 以 optimizer 用 gradient 更新參數值

        train_acc += np.sum(np.argmax(train_pred.cpu().data.numpy(), axis=1) == data[1].numpy())#获取预测 Variable 的内部 Tensor, 转换成numpy类型. 获取第二个维度中最大值(即可能性最大)索引,与真实值对比.

        train_loss += batch_loss.item()#张量转值

    model.eval()# 在测试时不用batch normalization和drop out

    with torch.no_grad():#内部不会track 梯度

        for i, data in enumerate(val_loader):#val_loader之前与train_loader一起获得

            val_pred = model(data[0].cuda())

            batch_loss = loss(val_pred, data[1].cuda())

            val_acc += np.sum(np.argmax(val_pred.cpu().data.numpy(), axis=1) == data[1].numpy())

            val_loss += batch_loss.item()

        #將結果 print 出來

        print('[%03d/%03d] %2.2f sec(s) Train Acc: %3.6f Loss: %3.6f | Val Acc: %3.6f loss: %3.6f' % \

            (epoch + 1, num_epoch, time.time()-epoch_start_time, \

             train_acc/train_set.__len__(), train_loss/train_set.__len__(), val_acc/val_set.__len__(), val_loss/val_set.__len__()))

Torch not compiled with CUDA enabled

[001/030] 23.37 sec(s) Train Acc: 0.250862 Loss: 0.017631 | Val Acc: 0.295918 loss: 0.015972

[030/030] 22.20 sec(s) Train Acc: 0.875329 Loss: 0.002861 | Val Acc: 0.624781 loss: 0.011972

train_val_x = np.concatenate((train_x, val_x), axis=0)#两个数组拼接

train_val_y = np.concatenate((train_y, val_y), axis=0)

train_val_set = ImgDataset(train_val_x, train_val_y, train_transform)

train_val_loader = DataLoader(train_val_set, batch_size=batch_size, shuffle=True) #train_val_set为实例化的1个dataset,然后用Dataloader 包起来

[001/030] 26.46 sec(s) Train Acc: 0.242103 Loss: 0.017428

[030/030] 26.52 sec(s) Train Acc: 0.907040 Loss: 0.002050

test_set = ImgDataset(test_x, transform=test_transform)

test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False)

model_best.eval()

prediction = []

with torch.no_grad():

    for i, data in enumerate(test_loader):

        test_pred = model_best(data.cuda())

        test_label = np.argmax(test_pred.cpu().data.numpy(), axis=1)

        for y in test_label:

            prediction.append(y)

#將結果寫入 csv 檔

with open("predict.csv", 'w') as f:

    f.write('Id,Category\n')

    for i, y in  enumerate(prediction):

        f.write('{},{}\n'.format(i, y))

网络层

输入

filter

stride

padding

输出

计算式

参数量

Conv Layer1

3*(128*128)

64*(3*3)

1

1

64*(128*128)

64*(3*3*3)

1728

Conv Layer2

64*(64*64)

128*(3*3)

1

1

128*(64*64)

128*(3*3*64)

73728

Conv Layer3

128*(32*32)

256*(3*3)

1

1

256*(32*32)

256*(3*3*128)

294912

Conv Layer4

256*(16*16)

512*(3*3)

1

1

512*(16*16)

512*(3*3*256)

1179648

Conv Layer5

512*(8*8)

512*(3*3)

1

1

512*(8*8)

512*(3*3*512)

2359296

FC1

512*4*4

1024

(8192+1)*1024

8389632

FC2

1024

512

(1024+1)*512

524800

FC3

512

11

(512+1)*11

5643

def params_count(model):

    """

    Compute the number of parameters.

    Args:

        model (model): model to count the number of parameters.

    """

    return np.sum([p.numel() for p in model.parameters()]).item()

model = Classifier()

print('params num:', params_count(model))

网络层

输入

filter

stride

padding

输出

计算式

参数量

Conv Layer1

3*(128*128)

128*(3*3)

1

1

128*(128*128)

128*(3*3*3)

3456

Conv Layer2

128*(64*64)

256*(3*3)

1

1

256*(64*64)

256*(3*3*128)

294912

Conv Layer3

256*(16*16)

512*(3*3)

1

1

512*(16*16)

512*(3*3*256)

1179648

FC1

512*4*4

1024

(8192+1)*1024

8389632

FC2

1024

512

(1024+1)*512

524800

FC3

512

11

(512+1)*11

5643

[030/050] 30.78 sec(s) Train Acc: 0.822927 Loss: 0.004031 | Val Acc: 0.596793 loss: 0.013568

[050/050] 30.84 sec(s) Train Acc: 0.936043 Loss: 0.001405 | Val Acc: 0.657726 loss: 0.013707

网络层

输入

输出

计算式

参数量

FC1

3*(128*128)

256

(3*128*128+1)*256

12583168

FC2

256

128

(256+1)*128

32896

FC3

128

64

(128+1)*64

8256

FC4

64

11

(64+1)*11

715

[030/050] 6.23 sec(s) Train Acc: 0.337928 Loss: 0.014742 | Val Acc: 0.306997 loss: 0.015497

[050/050] 6.63 sec(s) Train Acc: 0.391749 Loss: 0.013394 | Val Acc: 0.285423 loss: 0.016252

transforms.ToTensor() # 图片转化为张量Tensor，並把數值 normalize 到 [0,1] (data normalization)

    transforms.RandomHorizontalFlip() # 随机将图片水平翻转

    transforms.RandomRotation(15) # 随机选择图片

#法1

#image = Image.open(image_path)  # 读取图片

image = np.array(image, dtype=np.float32)  # PILImage->numpy 输出(h,w,c)

image = np.transpose(image, (2, 0, 1))  # np下维度转换使用transpose，类似矩阵转置

#image /= 255.0

image = torch.from_numpy(image)  # numpy->tensor, 张量和ndarray共享同一内存, 不能调整大小

#法2

image = cv2.imread(image_path)  # 使用cv读直接为numpy格式

image = image.astype(np.float32)

image /= 255.0

image = np.transpose(image, (2, 0, 1))

image = torch.from_numpy(image)

float() argument must be a string or a number, not 'Compose'

X = np.array(X, dtype=np.float32)  # PILImage->numpy 输出(h,w,c)

X = np.transpose(X, (2, 0, 1))  # np下维度转换使用transpose，类似矩阵转置

X = torch.from_numpy(X)  # numpy->tensor, 张量和ndarray共享同一内存, 不能调整大小

forward函数处

out = self.cnn(x)处

Given groups=1, weight of size [64, 3, 3, 3], expected input[128, 128, 128, 3] to have 3 channels, but got 128 channels instead

[030/030] 22.20 sec(s) Train Acc: 0.875329 Loss: 0.002861 | Val Acc: 0.624781 loss: 0.011972

[030/050] 20.69 sec(s) Train Acc: 0.848976 Loss: 0.003441 | Val Acc: 0.632945 loss: 0.011078

[050/050] 20.78 sec(s) Train Acc: 0.966552 Loss: 0.000791 | Val Acc: 0.627697 loss: 0.018501

[030/050] 18.74 sec(s) Train Acc: 0.978208 Loss: 0.000575 | Val Acc: 0.588338 loss: 0.018233

[050/050] 19.02 sec(s) Train Acc: 0.988648 Loss: 0.000283 | Val Acc: 0.607289 loss: 0.024831

def plot_confusion_matrix(cm, savename, title='Confusion Matrix'):

    plt.figure(figsize=(12, 8), dpi=100)

    np.set_printoptions(precision=2)

    # 在混淆矩阵中每格的概率值

    ind_array = np.arange(len(classes))

    x, y = np.meshgrid(ind_array, ind_array)

    for x_val, y_val in zip(x.flatten(), y.flatten()):

        c = cm[y_val][x_val]

        if c > 0.001:

            plt.text(x_val, y_val, "%0.2f" % (c,), color='red', fontsize=15, va='center', ha='center')

    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.binary)

    plt.title(title)

    plt.colorbar()

    xlocations = np.array(range(len(classes)))

    plt.xticks(xlocations, classes, rotation=90)

    plt.yticks(xlocations, classes)

    plt.ylabel('Actual label')

    plt.xlabel('Predict label')

    # offset the tick

    tick_marks = np.array(range(len(classes))) + 0.5

    plt.gca().set_xticks(tick_marks, minor=True)

    plt.gca().set_yticks(tick_marks, minor=True)

    plt.gca().xaxis.set_ticks_position('none')

    plt.gca().yaxis.set_ticks_position('none')

    plt.grid(True, which='minor', linestyle='-')

    plt.gcf().subplots_adjust(bottom=0.15)

    # show confusion matrix

    plt.savefig(savename, format='png')

    plt.show()

from sklearn.metrics import confusion_matrix

import matplotlib.pyplot as plt

# classes表示不同类别的名称，比如这有6个类别

classes = ['A', 'B', 'C', 'D', 'E', 'F']

random_numbers = np.random.randint(6, size=50)  # 6个类别，随机生成50个样本

y_true = random_numbers.copy()  # 样本实际标签

random_numbers[:10] = np.random.randint(6, size=10)  # 将前10个样本的值进行随机更改

y_pred = random_numbers  # 样本预测标签

# 获取混淆矩阵

cm = confusion_matrix(y_true, y_pred)

plot_confusion_matrix(cm, 'confusion_matrix.png', title='confusion matrix')

0

Bread

1

Dairy product

2

Dessert

3

Egg

4

Fried food

5

Meat

6

Noodles/Pasta

7

Rice

8

Seafood

9

Soup

10

Vegetable/Fruit

val_y

val_pred.cpu().copy()

prediction = []

with torch.no_grad():

    for i, data in enumerate(test_loader):

        test_pred = model_best(data.cuda())

        test_label = np.argmax(test_pred.cpu().data.numpy(), axis=1)

        for y in test_label:

            prediction.append(y)

for i, y in  enumerate(prediction):

        f.write('{},{}\n'.format(i, y))

model.eval()

with torch.no_grad():

    for i, data in enumerate(val_loader):

        val_pred = model(data[0].cuda())

        val_label = np.argmax(val_pred.cpu().data.numpy(), axis=1)

        for y in val_label:

            prediction_val.append(y)

# Normalize by row

cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

print(cm_normalized)