【Python】【Keras】重みデータの読み込み位置について

Question

お世話になります
最近 機械学習を 学び始めました

実行途中の重みデータですが
プログラム中のどこで 読み込めばよいかが 解りません

次のコードでは summary 表示後にしていますが
コメントのところの方が 適切でしょうか？

よろしく お願い致します

import os

import keras.backend as K
K.set_image_data_format('channels_first')
from keras.models import Sequential, Model
from keras.layers import Conv2D, ZeroPadding2D, BatchNormalization, Input
from keras.layers import Conv2DTranspose, Reshape, Activation, Cropping2D, Flatten
from keras.layers.advanced_activations import LeakyReLU
from keras.activations import relu
from keras.initializers import RandomNormal
conv_init = RandomNormal(0, 0.02)
gamma_init = RandomNormal(1., 0.02)


def DCGAN_D(isize, nz, nc, ndf, n_extra_layers=0):
    assert isize%2==0
    _ = inputs = Input(shape=(nc, isize, isize))
    _ = Conv2D(filters=ndf, kernel_size=4, strides=2, use_bias=False,
                        padding = "same",
                        kernel_initializer = conv_init, 
                        name = 'initial.conv.{0}-{1}'.format(nc, ndf)             
                        ) (_)
    _ = LeakyReLU(alpha=0.2, name = 'initial.relu.{0}'.format(ndf))(_)
    csize, cndf = isize// 2, ndf
    while csize > 5:
        assert csize%2==0
        in_feat = cndf
        out_feat = cndf*2
        _ = Conv2D(filters=out_feat, kernel_size=4, strides=2, use_bias=False,
                        padding = "same",
                        kernel_initializer = conv_init,
                        name = 'pyramid.{0}-{1}.conv'.format(in_feat, out_feat)             
                        ) (_)
        if 0: # toggle batchnormalization
            _ = BatchNormalization(name = 'pyramid.{0}.batchnorm'.format(out_feat),                                   
                                   momentum=0.9, axis=1, epsilon=1.01e-5,
                                   gamma_initializer = gamma_init, 
                                  )(_, training=1)        
        _ = LeakyReLU(alpha=0.2, name = 'pyramid.{0}.relu'.format(out_feat))(_)
        csize, cndf = (csize+1)//2, cndf*2
    _ = Conv2D(filters=1, kernel_size=csize, strides=1, use_bias=False,
                        kernel_initializer = conv_init,
                        name = 'final.{0}-{1}.conv'.format(cndf, 1)         
                        ) (_)
    outputs = Flatten()(_)
    return Model(inputs=inputs, outputs=outputs)




def DCGAN_G(isize, nz, nc, ngf, n_extra_layers=0):
    cngf= ngf//2
    tisize = isize
    while tisize > 5:
        cngf = cngf * 2
        assert tisize%2==0
        tisize = tisize // 2
    _ = inputs = Input(shape=(nz,))
    _ = Reshape((nz, 1,1))(_)
    _ = Conv2DTranspose(filters=cngf, kernel_size=tisize, strides=1, use_bias=False,
                           kernel_initializer = conv_init, 
                           name = 'initial.{0}-{1}.convt'.format(nz, cngf))(_)
    _ = BatchNormalization(gamma_initializer = gamma_init, momentum=0.9, axis=1, epsilon=1.01e-5,
                               name = 'initial.{0}.batchnorm'.format(cngf))(_, training=1)
    _ = Activation("relu", name = 'initial.{0}.relu'.format(cngf))(_)
    csize, cndf = tisize, cngf
    

    while csize < isize//2:
        in_feat = cngf
        out_feat = cngf//2
        _ = Conv2DTranspose(filters=out_feat, kernel_size=4, strides=2, use_bias=False,
                        kernel_initializer = conv_init, padding="same",
                        name = 'pyramid.{0}-{1}.convt'.format(in_feat, out_feat)             
                        ) (_)
        _ = BatchNormalization(gamma_initializer = gamma_init, 
                                   momentum=0.9, axis=1, epsilon=1.01e-5,
                                   name = 'pyramid.{0}.batchnorm'.format(out_feat))(_, training=1)
        
        _ = Activation("relu", name = 'pyramid.{0}.relu'.format(out_feat))(_)
        csize, cngf = csize*2, cngf//2
    _ = Conv2DTranspose(filters=nc, kernel_size=4, strides=2, use_bias=False,
                        kernel_initializer = conv_init, padding="same",
                        name = 'final.{0}-{1}.convt'.format(cngf, nc)
                        )(_)
    outputs = Activation("tanh", name = 'final.{0}.tanh'.format(nc))(_)
    return Model(inputs=inputs, outputs=outputs)




nc = 3
nz = 100
ngf = 8
ndf = 8
n_extra_layers = 0
Diters = 5
λ = 10

imageSize = 256
batchSize = 16
lrD = 1e-4
lrG = 1e-4



netD = DCGAN_D(imageSize, nz, nc, ndf, n_extra_layers)
netD.summary()


netG = DCGAN_G(imageSize, nz, nc, ngf, n_extra_layers)
netG.summary()


try:
    netG.load_weights('./netG.hdf5')
    netD.load_weights('./netD.hdf5')
    print('重みの読み込み完了') 
except:
    pass



from keras.optimizers import RMSprop, SGD, Adam



netD_real_input = Input(shape=(nc, imageSize, imageSize))
noisev = Input(shape=(nz,))
netD_fake_input = netG(noisev)

ϵ_input = K.placeholder(shape=(None,1,1,1))
netD_mixed_input = Input(shape=(nc, imageSize, imageSize),
    tensor=ϵ_input * netD_real_input + (1-ϵ_input) * netD_fake_input)


loss_real = K.mean(netD(netD_real_input))
loss_fake = K.mean(netD(netD_fake_input))

grad_mixed = K.gradients(netD(netD_mixed_input), [netD_mixed_input])[0]
norm_grad_mixed = K.sqrt(K.sum(K.square(grad_mixed), axis=[1,2,3]))
grad_penalty = K.mean(K.square(norm_grad_mixed -1))

loss = loss_fake - loss_real + λ * grad_penalty


training_updates = Adam(lr=lrD, beta_1=0.0, beta_2=0.9).get_updates(netD.trainable_weights,[],loss)
netD_train = K.function([netD_real_input, noisev, ϵ_input],
                        [loss_real, loss_fake],    
                        training_updates)




loss = -loss_fake 
training_updates = Adam(lr=lrG, beta_1=0.0, beta_2=0.9).get_updates(netG.trainable_weights,[], loss)
netG_train = K.function([noisev], [loss], training_updates)

"""
*************************************************
#       ここで load した方が 適切か？
*************************************************
"""



from PIL import Image
import numpy as np
import tarfile


from tensorflow.python.keras.preprocessing.image import ImageDataGenerator, load_img, img_to_array, array_to_img
import glob
import cv2
from keras.preprocessing import image
import os

train_X=[]
train_y=[]
files = glob.glob('/content/drive/train/*.*')

for img_file in files:
    img = cv2.imread(img_file)
    img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
    img = cv2.resize(img,(256,256),interpolation = cv2.INTER_AREA)
    img = np.transpose(img,(2,0,1))
    
    train_X.extend(img.reshape(-1,3,256,256)/255*2-1)
   


train_X = np.array(train_X)

train_X = np.concatenate([train_X[:,:,:,::-1], train_X])

print('画像データの読み込みが終了しました')


from IPython.display import display
def showX(X, rows=1):
    assert X.shape[0]%rows == 0
    int_X = ( (X+1)/2*255).clip(0,255).astype('uint8')
  
    int_X = np.moveaxis(int_X.reshape(-1,3,256,256), 1, 3)
    int_X = int_X.reshape(rows, -1, 256, 256,3).swapaxes(1,2).reshape(rows*256,-1, 3)
  
    (Image.fromarray(int_X)).save('./WGAN-GP_result.png')



fixed_noise = np.random.normal(size=(batchSize, nz)).astype('float32')


import time
t0 = time.time()
niter = 1000000
gen_iterations = 0
errG = 0
targetD = np.float32([2]*batchSize+[-2]*batchSize)[:, None]
targetG = np.ones(batchSize, dtype=np.float32)[:, None]
for epoch in range(niter):
    i = 0
   
    np.random.shuffle(train_X)
    batches = train_X.shape[0]//batchSize
    while i < batches:
        if gen_iterations < 25 or gen_iterations % 500 == 0:
            _Diters = 100
        else:
            _Diters = Diters
        j = 0
        while j < _Diters and i < batches:
            j+=1
            real_data = train_X[i*batchSize:(i+1)*batchSize]
            i+=1
            noise = np.random.normal(size=(batchSize, nz))        
            ϵ = np.random.uniform(size=(batchSize, 1, 1 ,1))        
            errD_real, errD_fake  = netD_train([real_data, noise, ϵ])
            errD = errD_real - errD_fake
       
        if gen_iterations%500==0:
            print('[%d/%d][%d/%d][%d] Loss_D: %f Loss_G: %f Loss_D_real: %f Loss_D_fake %f'
            % (epoch, niter, i, batches, gen_iterations,errD, errG, errD_real, errD_fake), time.time()-t0)
            fake = netG.predict(fixed_noise)
            showX(fake, 2)
        if gen_iterations % 5000 == 0:
            netG.save_weights('./netG.hdf5')
            netD.save_weights('./netD.hdf5')  
        
        noise = np.random.normal(size=(batchSize, nz))        
        errG, = netG_train([noise])
        gen_iterations+=1

`
追記：
質問は
一度保存した重みデータを 再度実行するときに 読み込むという意味です

追記2：
質問のコードは こちらを元に
WGAN-GPの実行いたしたく手直ししたものです

Colab 上での起動のため (時間制限があるので) 重みデータを (Google Driveに) 一旦 保存して
次の実行の際 そのデータを 読み込むことを想定しております

機械学習初心者で はじめから構築は難しく
既存のプログラムの実行して 勉強しております

model 定義後か Optimizer 定義後か
どちらで 重みデータを 読み込むのが
適切なのかが 勉強不足のため わかりませんので
質問いたしました

Comments

[Q71]

質問の意図が汲み取れませんでした。申し訳ありません。
「実行途中」とは、「学習中になんらかの理由で学習を中断した」の意図でしょうか。それとも、他の意図でしょうか。
「コメントの位置」とのことですが、画面の幅が狭いのでコードをよく読めませんでした。コードの最後にコメントがあります。また、インデントのつき方から、上から順に流れているようです。コメントの位置は、プログラムの実行順序でいうと、1番最後でしょうか。
申し訳ありませんが、以上2点、補足をお願いします。

[quickquip]

そもそもなぜ重みをロードするのか? そのロードしている重みは何なのか? 質問に挙げられたコードの**後に**何をする（=どのようなコードを書く）つもりなのか? という情報が足りてないと感じました。

Answer 1

プログラムの質問なのか、機械学習の質問なのか、よくわかりませんが。

プログラムの質問であれば、プログラムというのは、希望する結果を得るために実施する必要があることを、実施できる順番に並べたものです。「順番に」並べたものです。何を、どのような順番でするのが適切か。それはプログラムを作る要件に依存します。

機械学習の質問であれば、いや、これもプログラムの方に通じるか。その「一度保存した重みデータ」を、なんのために読み込む必要があるのかによります。あるいは、その情報が、何に対して必要なのか。

必要としているものに対して、必要な情報を、必要な順序で、必要な分だけ、用意してください。それを考えることが「プログラムを作る」です。考えたことを、プログラム言語に翻訳してください。プログラムをコードで作ろうとすると、難しいことが多いです。