not enough values to unpack (expected 2, got 1)の解決法

Question

efficientnet実装を試みているものです。
ようやく学習のところまでたどり着いたのですが、下記のerrorが出力され対応に苦慮しています。
Errorから2つの要素の入力が要求されているのに、1つしか入力されていないといった意味だと理解していますが、それが何のことなのか判然としません。ご教示いただけますでしょうか。

発生している問題・エラーメッセージ

(envtest2) C:\Users\orala\Desktop\new>python efficientnet.py
Using TensorFlow backend.
2021-05-23 18:12:00.241804: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudart64_101.dll
710
40
Found 710 images belonging to 2 classes.
Found 40 images belonging to 2 classes.
  0%|                                                                                           | 0/15 [00:00<?, ?it/s]
Traceback (most recent call last):
  File "efficientnet.py", line 216, in <module>
    for img, label in tqdm.auto.tqdm(train_dir):
ValueError: not enough values to unpack (expected 2, got 1)

該当のソースコード

import os
import random
import glob
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential, Model
from keras.layers import Input, Flatten, Dense
from keras import optimizers
from keras.callbacks import ModelCheckpoint, EarlyStopping
from keras import backend
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms 
import torchvision.datasets as datasets
import tqdm
import matplotlib.pyplot as plt


classes = ['cancer','normal']
nb_classes = len(classes)

#train val dir
train_dir = './dataset/train'
val_dir = './dataset/valid'
model_dir = './saved_model'

#num samples
train_samples = glob.glob(train_dir + '/*/*.jpg')
val_samples = glob.glob(val_dir + '/*/*.jpg')
train_samples = len(train_samples)
val_samples = len(val_samples)
print(train_samples)
print(val_samples)

#img size
img_w, img_h = 224,224

#keras image data generator
train_datagen = ImageDataGenerator(rescale = 1.0/255, zoom_range=0.2,horizontal_flip=True)
val_datagen = ImageDataGenerator(rescale=1.0 / 255)

train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(img_w,img_h),
    color_mode = 'rgb',
    classes = classes,
    class_mode = 'categorical',
    batch_size = 5
)

val_generator = val_datagen.flow_from_directory(
    val_dir,
    target_size=(img_w,img_h),
    color_mode = 'rgb',
    classes = classes,
    class_mode = 'categorical',
    batch_size = 5
)

#TO save model
checkpoint = ModelCheckpoint(
    filepath = os.path.join(
        model_dir,
        'model_16.hdf5'
    ),
    save_best_only=True
)

#TO early stopping
early_stopping = EarlyStopping(monitor='val_loss',patience=3,verbose=0,mode='auto')

### model ###
class Swish(nn.Module):
  """x*sigmoid(x)"""
  def __init__(self):
    super().__init__()
  def forward(self, x):
    return x*torch.sigmoid(x)

class DWBlock(nn.Module):
  # 出力が同じサイズになるようにパディングはk//2 (ただしkは奇数)
  def __init__(self, in_c, k, s, p, bias=False):
    if p != k//2:
      print("output may not be the same spatial size as input")
    super().__init__()
    self.dw = nn.Conv2d(in_c, in_c, kernel_size=k, stride=s, padding=p, groups=in_c, bias=bias)
    self.bn = nn.BatchNorm2d(in_c)
    self.act = Swish()

  def forward(self, x):
    out = self.act(self.bn(self.dw(x)))
    return out

class PWBlock(nn.Module):
  def __init__(self, in_c, out_c, bias=False, act="swish"):
    super().__init__()
    self.dw = nn.Conv2d(in_c, out_c, kernel_size=1, bias=bias)
    self.bn = nn.BatchNorm2d(out_c)
    if act=='swish':
      self.act = Swish()
    elif act is None:
      self.act = nn.Identity()

  def forward(self, x):
    out = self.act(self.bn(self.dw(x)))
    return out

class SEBlock(nn.Module):
  def __init__(self, in_c, h=8):
    super().__init__()
    # Squeeze
    self.gap = nn.AdaptiveAvgPool2d(1) 
    # Excitation
    self.fc1 = nn.Linear(in_c, in_c//h, bias=False) 
    self.act1 = Swish()
    self.fc2 = nn.Linear(in_c//h, in_c, bias=False)
    self.act2 = nn.Sigmoid()

  def forward(self, x):
    out = self.gap(x).squeeze(-1).squeeze(-1)
    out = self.act1(self.fc1(out))
    out = self.act2(self.fc2(out)).unsqueeze(-1).unsqueeze(-1)
    return out*x

class MBConv(nn.Module):
  def __init__(self, in_c, out_c, k=5, s=1, expansion=1):
    super().__init__()
    self.s = s
    self.in_c = in_c
    self.out_c = out_c
    self.pw1 = PWBlock(in_c, in_c*expansion, bias=False)
    self.dw = DWBlock(in_c*expansion, k=k, s=s, p=k//2, bias=False)
    self.se = SEBlock(in_c*expansion)
    self.pw2 = PWBlock(in_c*expansion, out_c, bias=False, act=None)

  def forward(self, x):
    out = self.pw2(self.se(self.dw(self.pw1(x))))
    if self.s == 1 and self.in_c==self.out_c:
      out = out+x
    return out

class EfficientNetB0(nn.Module):
  def __init__(self, n_c=3, n_classes=10):
    super().__init__()
    self.first = nn.Sequential(
        nn.Conv2d(n_c,32,3,1,1,bias=False),
        nn.BatchNorm2d(32),
        Swish()
    )
    self.mb1 = MBConv(32, 16, 3, expansion=1)
    self.mb6_1 = nn.Sequential(
        MBConv(16, 24, k=3, s=1, expansion=6),
        MBConv(24, 24, k=3, s=1, expansion=6)
    )
    self.mb6_2 = nn.Sequential(
        MBConv(24, 40, k=5, s=1, expansion=6),
        MBConv(40, 40, k=5, s=1, expansion=6)
    )
    #画像サイズ:32->16
    self.mb6_3 = nn.Sequential(
        MBConv(40, 80, k=3, s=2, expansion=6),
        MBConv(80, 80, k=3, s=1, expansion=6),
        MBConv(80, 80, k=3, s=1, expansion=6),
    )
    self.mb6_4 = nn.Sequential(
        MBConv(80, 112, k=5, s=1, expansion=6),
        MBConv(112, 112, k=5, s=1, expansion=6),
        MBConv(112, 112, k=5, s=1, expansion=6),
    )
    #画像サイズ: 16->8
    self.mb6_5 = nn.Sequential(
        MBConv(112, 192, k=5, s=2, expansion=6),
        MBConv(192, 192, k=5, s=1, expansion=6),
        MBConv(192, 192, k=5, s=1, expansion=6),
        MBConv(192, 192, k=5, s=1, expansion=6),
    )

    self.mb6_6 = nn.Sequential(
        MBConv(192, 320, k=3, s=1, expansion=6),
    )
    self.pw = PWBlock(320, 1280)
    self.gap = nn.AdaptiveAvgPool2d(1)
    self.dropout = nn.Dropout(0.2)
    self.fc = nn.Linear(1280, n_classes)

  def forward(self, x):
    out = self.first(x)
    out = self.mb1(out)
    out = self.mb6_1(out)
    out = self.mb6_2(out)
    out = self.mb6_3(out)
    out = self.mb6_4(out)
    out = self.mb6_5(out)
    out = self.mb6_6(out)
    out = self.pw(out)
    out = self.gap(out).view(x.size(0), -1)
    out = self.dropout(out)
    out = self.fc(out)
    return out

net = EfficientNetB0(n_c=3, n_classes=10)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[25, 40], gamma=0.1)

#train 
history = {'loss':[], 'acc':[], 'val_loss':[], 'val_acc':[]}
epochs = 50
device ='cuda:0' if torch.cuda.is_available() else 'cpu'
net = net.to(device)
for epoch in range(epochs):
    net.train()
    epoch_acc, epoch_loss = 0., 0.
    num_imgs = 0.
    for img, label in tqdm.auto.tqdm(train_dir):
        img, label = img.to(device), label.to(device)
        optimizer.zero_grad()
        output = net(img)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()

        epoch_loss += loss.data
        epoch_acc += sum(label == output.argmax(0))
        num_imgs += img.size(0)*1.0 # floatにするため1.0を掛けている。

    scheduler.step()
    epoch_loss /= num_imgs
    epoch_acc /= num_imgs
    history['loss'].append(epoch_loss)
    history['acc'].append(epoch_acc)    
    print(f'Epoch: {epoch}, loss:{epoch_loss}, acc:{epoch_acc}')

    net.eval()
    epoch_acc, epoch_loss = 0., 0.
    num_imgs = 0.
    for img, label in tqdm.auto.tqdm(test_dir):
        img, label = img.to(device), label.to(device)
        with torch.no_grad():
            output = net(img)
            loss = criterion(output, label)

            epoch_loss += loss.data
            epoch_acc += sum(label == output.argmax(0))
            num_imgs += img.size(0)*1.0 # floatにするため1.0を掛けている。

    epoch_loss /= num_imgs
    epoch_acc /= num_imgs
    history['val_loss'].append(epoch_loss)
    history['val_acc'].append(epoch_acc)
    print(f'Epoch: {epoch}, val_loss:{epoch_loss}, val_acc:{epoch_acc}')


x = list(range(epochs))
plt.figure()
plt.subplot(1,2,1)
plt.title('Loss')
plt.plot(x, history['loss'], 'bo')
plt.plot(x, history['val_loss'], 'b')

plt.subplot(1,2,2)
plt.title('Acc')
plt.plot(x, history['acc'], 'ro')
plt.plot(x, history['val_acc'], 'r')

Answer 1

そもそもの変数名の間違いですかね

ループ変数がimg,labelの2つあるので，2要素の値を返すイテレータを要求しているが，train_dirはstrだから，イテレートすると1要素しか返さないということです

Comments

[shujiu]

回答ありがとうございます。
では、train_dirはstrですので文字の要素のみ返しておらず、dataは出力されていないのでしょうか？
差し支えなければ、ローカルPC上の./dataset/trainのpath上のデータを出力したいのですが何か方法はないでしょうか。

[taC-h]

kerasは詳しくないですけど
train_generator
をfor文で回すのではないでしょうか
(代入した後使って無いですし)

[jbpb0]

質問者さん

・KerasのImageDataGeneratorとか使って画像読み込んでデータ化する
・PyTorchでニューラルネットのモデル作って学習する
のを混ぜてる時点でダメです
PyTorchで学習するなら、画像をデータ化するところもPyTorchでやらないと
(質問に書かれてるコードでは、Kerasでやってる部分はそれ以降で全く参照されてないので、それがあっても害はないのかもしれませんが、役にも立ってません)

https://teratail.com/questions/339778
にも書きましたけど、たとえば下記とか参考にして、PyTorchのやり方で画像読み込んでデータ化するコードを書いてください
https://pystyle.info/pytorch-train-classification-problem-using-a-pretrained-model/#outline__4_2
の「データセットを用意する」と書かれてるところ以降