DCGANの実装について

https://github.com/triwave33/GAN/tree/master/GAN/dcganを参考にkerasでDCGANを実装しています

epochが先に進まないのでどなたかご教授お願い致します。

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

FileNotFoundError: [Errno 2] No such file or directory: '/img/img/mnist__0.png'

該当のソースコード

python
1from __future__ import print_function, division
2
3from keras.datasets import mnist
4from keras.layers import Input, Dense, Reshape, Flatten, Dropout
5from keras.layers import BatchNormalization, Activation, ZeroPadding2D
6from keras.layers.advanced_activations import LeakyReLU
7from keras.layers.convolutional import UpSampling2D, Convolution2D
8from keras.models import Sequential, Model, load_model
9
10from keras.optimizers import Adam
11
12import matplotlib.pyplot as plt
13
14import sys
15
16import numpy as np
17
18class DCGAN():
19    
20    def __init__(self):
21        self.path = "/vans/img/img/"
22        self.img_rows = 28 
23        self.img_cols = 28
24        self.channels = 1
25        self.img_shape = (self.img_rows, self.img_cols, self.channels)
26        
27        self.z_dim = 5
28
29        self.row = 5
30        self.col = 5
31        self.row2 = 1 
32        self.col2 = 10
33        
34        # 画像生成用の固定された入力潜在変数
35        self.noise_fix1 = np.random.normal(0, 1, (self.row * self.col, self.z_dim)) 
36        # 連続的に潜在変数を変化させる際の開始、終了変数
37        self.noise_fix2 = np.random.normal(0, 1, (1, self.z_dim))
38        self.noise_fix3 = np.random.normal(0, 1, (1, self.z_dim))
39
40        # 横軸がiteration数のプロット保存用np.ndarray
41        self.g_loss_array = np.array([])
42        self.d_loss_array = np.array([])
43        self.d_accuracy_array = np.array([])
44        self.d_predict_true_num_array = np.array([])
45        self.c_predict_class_list = []
46
47        discriminator_optimizer = Adam(lr=1e-5, beta_1=0.1)
48        combined_optimizer = Adam(lr=2e-4, beta_1=0.5)
49
50        # discriminatorモデル
51        self.discriminator = self.build_discriminator()
52        self.discriminator.compile(loss='binary_crossentropy', 
53            optimizer=discriminator_optimizer,
54            metrics=['accuracy'])
55
56        # Generatorモデル
57        self.generator = self.build_generator()
58        # generatorは単体で学習しないのでコンパイルは必要ない
59        #self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)
60
61        self.combined = self.build_combined1()
62        #self.combined = self.build_combined2()
63        self.combined.compile(loss='binary_crossentropy', optimizer=combined_optimizer)
64
65        # Classifierモデル
66        self.classifier = self.build_classifier()
67
68    def build_generator(self):
69
70        noise_shape = (self.z_dim,)
71        model = Sequential()
72        model.add(Dense(1024, input_shape=noise_shape))
73        model.add(BatchNormalization())
74        model.add(Activation('relu'))
75        model.add(Dense(128*7*7))
76        model.add(BatchNormalization())
77        model.add(Activation('relu'))
78        model.add(Reshape((7,7,128), input_shape=(128*7*7,)))
79        model.add(UpSampling2D((2,2)))
80        model.add(Convolution2D(64,5,5,border_mode='same'))
81        model.add(BatchNormalization())
82        model.add(Activation('relu'))
83        model.add(UpSampling2D((2,2)))
84        model.add(Convolution2D(1,5,5,border_mode='same'))
85        model.add(Activation('tanh'))
86        model.summary()
87        return model
88
89    def build_discriminator(self):
90
91        img_shape = (self.img_rows, self.img_cols, self.channels)
92        
93        model = Sequential()
94        model.add(Convolution2D(64,5,5, subsample=(2,2),\
95                  border_mode='same', input_shape=img_shape))
96        model.add(LeakyReLU(0.2))
97        model.add(Convolution2D(128,5,5,subsample=(2,2)))
98        model.add(LeakyReLU(0.2))
99        model.add(Flatten())
100        model.add(Dense(256))
101        model.add(LeakyReLU(0.2))
102        model.add(Dropout(0.5))
103        model.add(Dense(1))
104        model.add(Activation('sigmoid'))   
105        return model
106    
107    def build_combined1(self):
108        self.discriminator.trainable = False
109        model = Sequential([self.generator, self.discriminator])
110        return model
111
112    def build_combined2(self):
113        z = Input(shape=(self.z_dim,))
114        img = self.generator(z)
115        self.discriminator.trainable = False
116        valid = self.discriminator(img)
117        model = Model(z, valid)
118        model.summary()
119        return model
120
121    def build_classifier(self):
122        model = load_model("cnn_model.h5")
123        model.load_weights('cnn_weight.h5')
124        return model
125
126
127
128    def train(self, epochs, batch_size=128, save_interval=50):
129
130        (X_train, _), (_, _) = mnist.load_data()
131
132        X_train = (X_train.astype(np.float32) - 127.5) / 127.5
133        X_train = np.expand_dims(X_train, axis=3)
134
135        half_batch = int(batch_size / 2)
136
137        self.g_loss_array = np.zeros(epochs)
138        self.d_loss_array = np.zeros(epochs)
139        self.d_accuracy_array = np.zeros(epochs)
140        self.d_predict_true_num_array = np.zeros(epochs)
141
142        for epoch in range(epochs):
143
144            noise = np.random.normal(0, 1, (half_batch, self.z_dim))
145            gen_imgs = self.generator.predict(noise)
146
147            idx = np.random.randint(0, X_train.shape[0], half_batch)
148            imgs = X_train[idx]
149
150            d_loss_real = self.discriminator.train_on_batch(imgs, np.ones((half_batch, 1)))
151            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, np.zeros((half_batch, 1)))
152            
153            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
154
155            d_predict = self.discriminator.predict_classes(np.concatenate([gen_imgs,imgs]), verbose=0)
156            d_predict = np.sum(d_predict)
157            c_predict = self.classifier.predict_classes(np.concatenate([gen_imgs,imgs]), verbose=0)
158
159            noise = np.random.normal(0, 1, (batch_size, self.z_dim))
160
161            valid_y = np.array([1] * batch_size)
162
163            g_loss = self.combined.train_on_batch(noise, valid_y)
164
165            print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))
166            self.g_loss_array[epoch] = g_loss
167            self.d_loss_array[epoch] = d_loss[0]
168            self.d_accuracy_array[epoch] = 100*d_loss[1]
169            self.d_predict_true_num_array[epoch] = d_predict
170            self.c_predict_class_list.append(c_predict)
171
172            if epoch % save_interval == 0:
173                
174                self.save_imgs(self.row, self.col, epoch, '', noise)
175                
176                self.save_imgs(self.row, self.col, epoch, 'fromFixedValue', self.noise_fix1)
177               
178                total_images = self.row*self.col
179                noise_trans = np.zeros((total_images, self.z_dim))
180                for i in range(total_images):
181                    t = (i*1.)/((total_images-1)*1.)
182                    noise_trans[i,:] = t * self.noise_fix2 + (1-t) * self.noise_fix3
183                self.save_imgs(self.row2, self.col2, epoch, 'trans', noise_trans)
184                noise = np.random.normal(0, 1, (10000, self.z_dim))
185                class_res = self.classifier.predict_classes(self.generator.predict(noise), verbose=0)
186               
187                plt.hist(class_res)
188                plt.savefig("/img/img/mnist_hist_%d.png" % epoch)
189                plt.ylim(0,2000)
190                plt.close()
191
192                fig, ax = plt.subplots(4,1, figsize=(8.27,11.69))
193                ax[0].plot(self.g_loss_array[:epoch])
194                ax[0].set_title("g_loss")
195                ax[1].plot(self.d_loss_array[:epoch])
196                ax[1].set_title("d_loss")
197                ax[2].plot(self.d_accuracy_array[:epoch])
198                ax[2].set_title("d_accuracy")
199                ax[3].plot(self.d_predict_true_num_array[:epoch])
200                ax[3].set_title("d_predict_true_num_array")
201                fig.suptitle("epoch: %5d" % epoch)
202                fig.savefig(self.path + "training_%d.png" % epoch)
203                plt.close()
204
205        self.generator.save_weights(self.path + "generator_%s.h5" % epoch)
206        self.discriminator.save_weights(self.path + "discriminator_%s.h5" % epoch)
207
208
209            
210
211    def save_imgs(self, row, col, epoch, filename, noise):
212    
213        gen_imgs = self.generator.predict(noise)
214    
215        gen_imgs = 0.5 * gen_imgs + 0.5
216    
217    
218        fig, axs = plt.subplots(row, col)
219        cnt = 0
220        if row == 1:
221            for j in range(col):
222                axs[j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
223                axs[j].axis('off')
224                cnt += 1
225        else:
226            for i in range(row):
227                for j in range(col):
228                    axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
229                    axs[i,j].axis('off')
230                    cnt += 1
231
232        fig.suptitle("epoch: %5d" % epoch)
233        fig.savefig("/img/img/mnist_%s_%d.png" % (filename, epoch))
234        plt.close()
235    
236if __name__ == '__main__':
237    gan = DCGAN()
238    gan.train(epochs=100000, batch_size=32, save_interval=1000)