質問編集履歴

1 説明した

Quad

Quad score 18

2019/07/23 09:45  投稿

dcganを実装したい(コピペ)がエラーが出る
### 前提・実現したいこと
[このサイト](https://qiita.com/berry-clione/items/c37f292231434fd2067a)のコードを使って画像生成をしようと考えました!
### 発生している問題・エラーメッセージ
しかしエラーが
```
---------------------------------------------------------------------------
ValueError                               Traceback (most recent call last)
<ipython-input-14-473f5793b469> in <module>()
   262        check_noise=check_noise,
   263        r=r,
--> 264        c=c
   265    )
<ipython-input-14-473f5793b469> in train(self, iterations, batch_size, save_interval, model_interval, check_noise, r, c)
   129            # Training Discriminator
   130            # -----------------
--> 131            idx = np.random.randint(0, X_train.shape[0], half_batch)
   132
   133            imgs = X_train[idx]
mtrand.pyx in mtrand.RandomState.randint()
ValueError: Range cannot be empty (low >= high) unless no samples are taken
```
### 該当のソースコード
文字数ぎりぎりなのでimportなど抜いています  
```python
np.random.seed(0)
np.random.RandomState(0)
tf.set_random_seed(0)
config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))
session = tf.Session(config=config)
tensorflow_backend.set_session(session)
# root_dir = "/home/takusub/PycharmProjects/Samples/dcgan/kill_me_baby_datasets/"
root_dir = "./" ### keras_dcgan.pyが保存されているディレクトリのフルパス
input_img_dir = "./proimages"
save_dir = "./genimages"
class DCGAN():
   def __init__(self):
       self.class_names = os.listdir(root_dir)
       self.shape = (128, 128, 3)
       self.z_dim = 100
       optimizer = Adam(lr=0.0002, beta_1=0.5)
       self.discriminator = self.build_discriminator()
       self.discriminator.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
       self.generator = self.build_generator()
       # self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)
       z = Input(shape=(self.z_dim,))
       img = self.generator(z)
       self.discriminator.trainable = False
       valid = self.discriminator(img)
       self.combined = Model(z, valid)
       self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)
   def build_generator(self):
       noise_shape = (self.z_dim,)
       model = Sequential()
       model.add(Dense(128 * 32 * 32, activation="relu", input_shape=noise_shape))
       model.add(Reshape((32, 32, 128)))
       model.add(BatchNormalization(momentum=0.8))
       model.add(UpSampling2D())
       model.add(Conv2D(128, kernel_size=3, padding="same"))
       model.add(Activation("relu"))
       model.add(BatchNormalization(momentum=0.8))
       model.add(UpSampling2D())
       model.add(Conv2D(64, kernel_size=3, padding="same"))
       model.add(Activation("relu"))
       model.add(BatchNormalization(momentum=0.8))
       model.add(Conv2D(3, kernel_size=3, padding="same"))
       model.add(Activation("tanh"))
       model.summary()
       noise = Input(shape=noise_shape)
       img = model(noise)
       return Model(noise, img)
   def build_discriminator(self):
       img_shape = self.shape
       model = Sequential()
       model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=img_shape, padding="same"))
       model.add(LeakyReLU(alpha=0.2))
       model.add(Dropout(0.25))
       model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
       model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))
       model.add(LeakyReLU(alpha=0.2))
       model.add(Dropout(0.25))
       model.add(BatchNormalization(momentum=0.8))
       model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
       model.add(LeakyReLU(alpha=0.2))
       model.add(Dropout(0.25))
       model.add(BatchNormalization(momentum=0.8))
       model.add(Conv2D(256, kernel_size=3, strides=1, padding="same"))
       model.add(LeakyReLU(alpha=0.2))
       model.add(Dropout(0.25))
       model.add(Flatten())
       model.add(Dense(1, activation='sigmoid'))
       model.summary()
       img = Input(shape=img_shape)
       validity = model(img)
       return Model(img, validity)
   def build_combined(self):
       self.discriminator.trainable = False
       model = Sequential([self.generator, self.discriminator])
       return model
   def train(self, iterations, batch_size=128, save_interval=50, model_interval=10000, check_noise=None, r=5, c=5):
       X_train, labels = self.load_imgs()
       half_batch = int(batch_size / 2)
       X_train = (X_train.astype(np.float32) - 127.5) / 127.5
       for iteration in range(iterations):
           # ------------------
           # Training Discriminator
           # -----------------
           idx = np.random.randint(0, X_train.shape[0], half_batch)
           imgs = X_train[idx]
           noise = np.random.uniform(-1, 1, (half_batch, self.z_dim))
           gen_imgs = self.generator.predict(noise)
           d_loss_real = self.discriminator.train_on_batch(imgs, np.ones((half_batch, 1)))
           d_loss_fake = self.discriminator.train_on_batch(gen_imgs, np.zeros((half_batch, 1)))
           d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
           # -----------------
           # Training Generator
           # -----------------
           noise = np.random.uniform(-1, 1, (batch_size, self.z_dim))
           g_loss = self.combined.train_on_batch(noise, np.ones((batch_size, 1)))
           print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration, d_loss[0], 100 * d_loss[1], g_loss))
           if iteration % save_interval == 0:
               self.save_imgs(iteration, check_noise, r, c)
               start = np.expand_dims(check_noise[0], axis=0)
               end = np.expand_dims(check_noise[1], axis=0)
               resultImage = self.visualizeInterpolation(start=start, end=end)
               # cv2.imwrite("images/latent/" + "latent_{}.png".format(iteration), resultImage)
               cv2.imwrite(save_dir + "latent_{}.png".format(iteration), resultImage)
               if iteration % model_interval == 0:
                   # self.generator.save("ganmodels/dcgan-{}-iter.h5".format(iteration))
                   self.generator.save("mb_dcgan-{}-iter.h5".format(iteration))
   def save_imgs(self, iteration, check_noise, r, c):
       noise = check_noise
       gen_imgs = self.generator.predict(noise)
       # 0-1 rescale
       gen_imgs = 0.5 * gen_imgs + 0.5
       fig, axs = plt.subplots(r, c)
       cnt = 0
       for i in range(r):
           for j in range(c):
               axs[i, j].imshow(gen_imgs[cnt, :, :, :])
               axs[i, j].axis('off')
               cnt += 1
       fig.savefig(save_dir + '%d.png' % iteration)
       # fig.savefig('images/gen_imgs/kill_me_%d.png' % iteration)
       plt.close()
   def load_imgs(self):
       img_paths = []
       labels = []
       images = []
       # for cl_name in self.class_names:
       #    img_names = os.listdir(os.path.join(root_dir, cl_name))
       #    for img_name in img_names:
       #        img_paths.append(os.path.abspath(os.path.join(root_dir, cl_name, img_name)))
       #        hot_cl_name = self.get_class_one_hot(cl_name)
       #        labels.append(hot_cl_name)
       for cl_name in self.class_names:
           if cl_name == input_img_dir:
               img_names = os.listdir(os.path.join(root_dir, cl_name))
               for img_name in img_names:
                   img_paths.append(os.path.abspath(os.path.join(root_dir, cl_name, img_name)))
                   hot_cl_name = self.get_class_one_hot(cl_name)
                   labels.append(hot_cl_name)
       for img_path in img_paths:
           img = cv2.imread(img_path)
           img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
           images.append(img)
       images = np.array(images)
       return (np.array(images), np.array(labels))
   def get_class_one_hot(self, class_str):
       label_encoded = self.class_names.index(class_str)
       label_hot = np_utils.to_categorical(label_encoded, len(self.class_names))
       label_hot = label_hot
       return label_hot
   def visualizeInterpolation(self, start, end, save=True, nbSteps=10):
       print("Generating interpolations...")
       steps = nbSteps
       latentStart = start
       latentEnd = end
       startImg = self.generator.predict(latentStart)
       endImg = self.generator.predict(latentEnd)
       vectors = []
       alphaValues = np.linspace(0, 1, steps)
       for alpha in alphaValues:
           vector = latentStart * (1 - alpha) + latentEnd * alpha
           vectors.append(vector)
       vectors = np.array(vectors)
       resultLatent = None
       resultImage = None
       for i, vec in enumerate(vectors):
           gen_img = np.squeeze(self.generator.predict(vec), axis=0)
           gen_img = (0.5 * gen_img + 0.5) * 255
           interpolatedImage = cv2.cvtColor(gen_img, cv2.COLOR_RGB2BGR)
           interpolatedImage = interpolatedImage.astype(np.uint8)
           resultImage = interpolatedImage if resultImage is None else np.hstack([resultImage, interpolatedImage])
       return resultImage
if __name__ == '__main__':
   dcgan = DCGAN()
   r, c = 2,2
   check_noise = np.random.uniform(-1, 1, (r * c, 100))
   dcgan.train(
       iterations=200000,
       batch_size=32,
       # save_interval=1000,
       save_interval=50, ### epoch回数が50の倍数になったときに、generator生成画像を保存
       model_interval=5000,
       check_noise=check_noise,
       r=r,
       c=c
   )
```
### 試したこと
調べると、X_train.shape[0]が存在しないのが原因なのではないかと思いました。
しかしX_train.shape[0]なんてどこで使うのかが分かりません
### 補足情報(FW/ツールのバージョンなど)
python3,google colaboratory
  • Python

    30281 questions

    Pythonは、コードの読みやすさが特徴的なプログラミング言語の1つです。 強い型付け、動的型付けに対応しており、後方互換性がないバージョン2系とバージョン3系が使用されています。 商用製品の開発にも無料で使用でき、OSだけでなく仮想環境にも対応。Unicodeによる文字列操作をサポートしているため、日本語処理も標準で可能です。

  • Python 3.x

    17489 questions

    Python 3はPythonプログラミング言語の最新バージョンであり、2008年12月3日にリリースされました。

思考するエンジニアのためのQ&Aサイト「teratail」について詳しく知る