Mixupを使うと学習データへの精度が下がる

Question

実現したいこと

Mixupによるデータ水増しの有効性を調べるためにFashion-Mnistを用いてシミュレーションをしています．

testデータへのAccuracyは殆ど差がないのですが，Mixupを適用しない場合の精度に比べて，MIxup適用後の学習データでのAccuracyが大きく低下してしまい，困っています．
Mixupは性能向上に寄与する手法として提案されたと記憶しているのですが，こういうものなのでしょうか？
もしくは，プログラムのどこかに問題があるのでしょうか？
分かる方いたら教えて頂けるとありがたいです．
・Mixup無し

・Mixup適用後

該当のソースコード

#  必要ライブラリのロード
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import models
from torchvision.models.feature_extraction import create_feature_extractor
#from memory_profiler import profile
#from pytorch_memlab import profile
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from IPython.display import display
import time
import pickle
import pandas as pd
import seaborn as sns
from sklearn.datasets import load_iris
from sklearn.utils import shuffle
# データセットの読み込み
from sklearn.model_selection import train_test_split

train_data = torchvision.datasets.FashionMNIST('./fashion-mnist', train=True, download=True, transform=torchvision.transforms.ToTensor())
test_data = torchvision.datasets.FashionMNIST('./fashion-mnist', train=False, download=True, transform=torchvision.transforms.ToTensor())
random_state=0 #分割する際のseed
np.random.seed(5) #Mixupの際のseed
mix = True #mixupするか

train_data.data,train_data.targets = shuffle(train_data.data,train_data.targets)
x_train, y_train = train_data.data, train_data.targets
x_test, y_test = test_data.data, test_data.targets

if torch.cuda.is_available() == True:
  model = mnist_Net().to('cuda')
else:
  model = mnist_Net()

y_train_enc = []
for i in range(len(y_train)):#Mixupを適用するために教師データをone-hot encodeへ
  y_train_enc.append([0,0,0,0,0,0,0,0,0,0])
  y_train_enc[i][y_train[i]] = 1
y_train_enc = torch.tensor(y_train_enc)

mixup_rate = 0.5 #学習データに対するMixupデータの割合
mixup_size = int(len(x_train)*mixup_rate)
mixup_data_x = []
mixup_data_y = []
for i in range(mixup_size):
  index_1 = np.random.randint(0, len(x_train)-1) #x_1,y_1のindex
  index_2 = np.random.randint(0, len(x_train)-1) #x_2,y_2のindex
  if index_1 == index_2:#x_1,x_2が同じ時を避ける
    if index_1 == 0:
      index_2 += 1
    else:
      index_2 -= 1
  x_1 = x_train[index_1]
  y_1 = y_train_enc[index_1]
  x_2 = x_train[index_2]
  y_2 = y_train_enc[index_2]
  x,y = mixup(x_1,y_1,x_2,y_2)
  mixup_data_x.append(x)
  mixup_data_y.append(y)
mixup_data_x = torch.stack(mixup_data_x)
mixup_data_y = torch.stack(mixup_data_y)

x_train,y_train_enc = shuffle(x_train,y_train_enc)

x_train_mix = np.append(mixup_data_x, x_train,axis= 0)
y_train_mix = np.append(mixup_data_y, y_train_enc,axis= 0)


if mix == False:
  x_train = x_train
  y_train_enc = y_train_enc
else:
  x_train = torch.tensor(x_train_mix)
  y_train_enc = torch.tensor(y_train_mix)

optimizer = torch.optim.Adam(model.parameters())
epoch = 150
batch = 1000
iteration = int(len(x_train)/batch)
loss_train = []
acc_train = []
loss_test = []
acc_test = []
ce = nn.CrossEntropyLoss()
for i in range(epoch):
  if i % 10 == 0:
    print('epoch:', i)

  loss_total_train = 0
  rmse_train = 0
  x_train,y_train_enc = shuffle(x_train,y_train_enc)
  y_output = []
  y_output_test = []
  model.train()
  for j in range(iteration):
    x_train_batch = x_train[j*batch:(j+1)*batch].to(torch.float32).to('cuda')
    x_train_batch = torch.unsqueeze(x_train_batch, dim=1)
    y_train_batch = y_train_enc[j*batch:(j+1)*batch].to(torch.float32).to('cuda') 

    optimizer.zero_grad()
    y = model(x_train_batch)
    #y_train_batch = y_train_batch.reshape(batch,1)
    loss = ce(y, y_train_batch)
    loss_total_train += loss.to('cpu')
    loss.backward()
    optimizer.step()

    y_output.append(torch.argmax(y,dim = 1).to('cpu').detach().numpy())
  loss_train.append(loss_total_train.detach().numpy()/len(x_train))
  acc = 0
  y_output = np.stack(y_output).flatten()
  for n in range(len(x_train)):
    if y_output[n] == torch.argmax(y_train_enc[n],dim=0):
      acc += 1
  acc_train.append(acc/len(x_train))
  model.eval()
  y = model(torch.unsqueeze(x_test.to(torch.float32).to('cuda'),dim=1))

  loss = ce(y, y_test.to(torch.int64).to('cuda'))
  y_output_test.append(torch.argmax(y,dim = 1).to('cpu').detach().numpy())
  loss_test.append(loss.to('cpu').detach().numpy())
  acc = 0
  for n in range(len(x_test)):
    if y_output_test[0][n] == y_test[n]:
      acc += 1
  acc_test.append(acc/len(x_test))

def mixup(x_1,y_1,x_2,y_2, alpha = 1):
  l = np.random.beta(1, 1)
  x_l = l#.reshape(1, 1, 1)
  y_l = l#.reshape(1, )
  mix_x = x_1*x_l + x_2*(1-x_l)
  mix_y = y_1*y_l + y_2*(1-y_l)
  return mix_x, mix_y

class mnist_Net(nn.Module):
  def __init__(self):
    super(mnist_Net, self).__init__()
    self.features = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.BatchNorm2d(32),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.BatchNorm2d(64),
            nn.MaxPool2d(kernel_size=2),
    )
    self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(64 * 7 * 7, 128),
            nn.ReLU(),
            nn.Dropout(),
            nn.Linear(128, 256),
            nn.ReLU(),
            nn.Dropout(),
            nn.Linear(256,128),
            nn.ReLU(),
            nn.Dropout(),
            nn.Linear(128, 10),
    )
  def forward(self, x):
    x = self.features(x)
    x = torch.flatten(x, 1)
    x = self.classifier(x)
    return x

Comments

[jbpb0]

Mixupが作成した画像を、ファイルに保存して確認してみたら、いかがでしょうか
現実にはありえないような変な形のものが写ってる画像が大量に作成されてたりするかも

[RyosuK.S]

うーん、普通ですね·····
まさに、2枚の画像を足し合わせた様な感じです·····

[ps_aux_grep]

とりあえずデータは正規化されておらず，値域が0~255のままのようですね，
testそのままでtrainがおかしいということは，Dropoutしすぎな気がします．
デフォルトでDropout1つにつき50%のノードが不活性化するので，それを4回通すとすると単純計算で6.25%のノードの情報しか伝播してません，mixup無しでは1クラスしか指す必要がなかったものの，mixupありでは複数クラスを指す必要がある中で，6.25%の情報では不足していたのでしょうね．Dropout率を16%にすると4回通しても50%の情報を伝搬できるので，train精度が元に戻ると考えます．

[jbpb0]

> 2枚の画像を足し合わせた様な感じ

「靴」と「バッグ」が合成された、現実にはありえないような画像で学習しても、と思ったのですが、Mixupってそういうもので、それで効果があるのですね
失礼しました

[ps_aux_grep]

てかMixUpによる水増しに関してですが，結局のところ水増しになってませんね，
オフラインDAによるMixUpは水増しになりませんので，オンラインDAの検討を願います．

同じ条件で実験したところ，オンラインDAにするだけでtestデータへの精度よりもtrainデータの方が良い精度を示しました．