質問をすることでしか得られない、回答やアドバイスがある。

15分調べてもわからないことは、質問しよう!

ただいまの
回答率

90.53%

  • Python

    11198questions

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

  • 機械学習

    928questions

    機械学習は、データからパターンを自動的に発見し、そこから知能的な判断を下すためのコンピューターアルゴリズムを指します。人工知能における課題のひとつです。

  • TensorFlow

    888questions

  • NumPy

    617questions

    NumPyはPythonのプログラミング言語の科学的と数学的なコンピューティングに関する拡張モジュールです。

  • Matplotlib

    435questions

    MatplotlibはPythonのおよび、NumPy用のグラフ描画ライブラリです。多くの場合、IPythonと連携して使われます。

RGB画像の1次元配列を画像の配列にする

受付中

回答 0

投稿

  • 評価
  • クリップ 0
  • VIEW 504

mirai0322

score 14

 やりたいこと

画像生成プログラムで生成した画像のビュワープログラムを書いています。
画像をreshapeし、matplotlibのimshowで表示させたいのですが、期待どおりに表示されず困っています。

全体の流れは、以下の通りです。
生成プログラムにて50x50(RGB値)のサイズの画像を生成し、1枚=1次元配列としてpkl形式で保存し、ビュワープログラムにて画像読み込み、表示させる。

調べてみたのですが、いまいち理解できず、質問する考えに至りました。
回答いただけるとありがたいです。

※生成プログラムの学習が上手くいっていないのでおかしい部分がありましたら
そちらも教えていただるとありがたいです。

 生成プログラム

# 1 ライブラリのインポート
import tensorflow as tf
import datetime as dt
import numpy as np

#学習過程で生成される画像の保管はpkl形式
import pickle as pkl

#活性化関数を指定する際に使用
from functools import partial

#各種パラメータ
#エポック数(学習回数)ビュアーで定義
EPOCHS = 100
#バッチサイズ 一度に供給するデータの数
BATCH_SIZE = 50
#学習率
LEARNING_RATE = 0.001
#活性化関数のハイパーパラメータ設定
ALPHA = 0.01

categories = ["cat", "dog"]
nb_classes = len(categories)

# 2 生成モデル(Generator)を作る関数の定義

def generator(randomData, alpha, reuse=False):
    with tf.variable_scope('GAN/generator', reuse=reuse):
        #隠れ層
        h1 = tf.layers.dense(randomData, 256, \
            activation=partial(tf.nn.leaky_relu, alpha=alpha))

        #出力層
        o1 = tf.layers.dense(h1, 50*50*3, activation=None)
        #活性化関数
        img = tf.tanh(o1)

        return img

# 3 識別モデル(Discriminator)を作る関数の定義
def discriminator(img, alpha, reuse=False) :
    with tf.variable_scope('GAN/discriminator', reuse=reuse):
        #隠れ層
        h1 = tf.layers.dense(img, 128, activation=partial(tf.nn.leaky_relu, alpha=alpha))
        #出力層
        D_logits = tf.layers.dense(h1, 1, activation=None)
        #活性化関数
        D = tf.nn.sigmoid(D_logits)

        return D, D_logits

if __name__ == '__main__':
    #データをロードする
    image_train, image_test, label_train, label_test = np.load("./animal.npy")
    #データを正規化する
    image_train = image_train.astype("float") / 256
    image_test = image_test.astype("float") / 256
    #label_train = np_utils.to_categorical(label_train, nb_classes)
    #label_test = np_utils.to_categorical(label_test, nb_classes)

    #処理開始時間の取得
    tstamp_s = dt.datetime.now().strftime("%H:%M:%S")

    #プレースホルダー
    #本物の画像データ(50*50px)をバッチサイズ分保管する
    ph_realData = tf.placeholder(tf.float32, (BATCH_SIZE, 50*50*3))
    #100次元の一様乱数を保管するプレースホルダーを準備
    #サイズは、学習時はバッチサイズの100件
    ph_randomData = tf.placeholder(tf.float32, (None, 100))

    #一様乱数を与えて画像生成
    gimage = generator(ph_randomData, ALPHA)

    #本物の画像を与えて判定結果を取得
    real_D, real_D_logits = discriminator(ph_realData, ALPHA)

    #生成画像を与えて判定結果を取得
    fake_D, fake_D_logits = discriminator(gimage, ALPHA, reuse=True)

    # 4 損失関数の実装
    #本物画像(ラベル=1)との誤差を
    #クロスエントロピーの平均として取得
    d_real_xentropy = \
    tf.nn.sigmoid_cross_entropy_with_logits(\
        logits=real_D_logits, labels=tf.ones_like(real_D))
    loss_real = tf.reduce_mean(d_real_xentropy)

    ##生成画像(ラベル=0)との誤差を
    #クロスエントロピーの平均として取得
    d_fake_xentropy = \
    tf.nn.sigmoid_cross_entropy_with_logits(\
        logits=fake_D_logits, labels=tf.zeros_like(fake_D))
    loss_fake = tf.reduce_mean(d_fake_xentropy)

    #discriminatorの誤差は本物画像、生成画像における誤差を合計した値
    d_loss = loss_real + loss_fake

    #Generatorの誤差を取得
    g_xentropy = tf.nn.sigmoid_cross_entropy_with_logits(\
        logits=fake_D_logits, labels=tf.ones_like(fake_D))
    g_loss = tf.reduce_mean(g_xentropy)

    #discriminatorの最適化を行う学習パラメータを取得
    d_training_parameter = \
    [trainVar for trainVar in tf.trainable_variables() \
    if 'GAN/discriminator' in trainVar.name]

    #generatorの最適化を行う学習パラメータを取得
    g_training_parameter = \
    [trainVar for trainVar in tf.trainable_variables() \
    if 'GAN/generator' in trainVar.name]

    #パラメータの最適化
    #Discriminatorのパラメータを更新
    d_optimize = tf.train.AdamOptimizer(\
        LEARNING_RATE).minimize(d_loss, var_list=d_training_parameter)

    #generatorのパラメータを更新
    g_optimize = tf.train.AdamOptimizer(\
        LEARNING_RATE).minimize(g_loss, var_list=g_training_parameter)   

     #途中経過を格納する変数
    save_gimage = []
    save_loss = []

    # 5 学習処理の実装
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        #EPOCHS数分繰り返す
        for e in range(EPOCHS):
            #バッチサイズ50
            for i in range(len(image_train)//BATCH_SIZE):
                img = []
                lbl = []
                for j in range(0, BATCH_SIZE):
                    rand = np.random.randint(len(image_train))
                    img.append(image_train[rand])
                    lbl.append(label_train[rand])

                batch_tuple = (np.array(img), np.array(lbl))
                batch_images = batch_tuple[0].reshape((BATCH_SIZE, 50*50*3))
                #generatorにて活性化関数tanhを使用したため、レンジを合わせる
                batch_images = batch_images * 2 - 1
                #generatorに渡す一様分布のランダムノイズ生成
                #値は-1~1まで、サイズはbatch_size*100
                batch_z = np.random.uniform(-1, 1, size=(BATCH_SIZE, 100))
                #最適化計算・パラメータ更新を行う
                #discriminatorの最適化に使うデータ群をfeed_dictで与える
                sess.run(d_optimize, feed_dict=\
                    {ph_realData:batch_images, ph_randomData:batch_z})

                #generatorの最適化と最適化に使うデータ群をfeed_dictで与える
                sess.run(g_optimize, feed_dict=\
                    {ph_randomData: batch_z})

            #トレーニングロスを記録
            train_loss_d = sess.run(d_loss, \
                {ph_randomData:batch_z, ph_realData:batch_images})
            #evalはgeneratorのロスを出力する命令
            train_loss_g = g_loss.eval({ph_randomData: batch_z})

            #学習過程の表示
            print(\
                '{0} Epoch={1}/{2}, DLoss={3:.4F}, GLoss={4:.4f}'. \
                format(dt.datetime.now().strftime("%H:%M:%S"), e+1, \
                    EPOCHS, train_loss_d, train_loss_g))

            #lossを格納するためのリストに追加する
            #後で可視化できるようにする
            save_loss.append((train_loss_d, train_loss_g))

            #学習過程の生成モデルで画像を生成して保存
            #一様乱数を25個生成して、そのデータを使って画像を生成し保存
            randomData = np.random.uniform(-1, 1, size=(25, 100))
            #gen_samplesに現時点のモデルで作ったデータを読ませておく
            #ノイズ、サイズ、ユニット数(128),reuseは状態維持
            #データはrandomDataとしてfeed_dict西頴娃
            gen_samples = sess.run(generator(ph_randomData, \
                ALPHA, True), feed_dict={ph_randomData:randomData})
            #生成画像を保存
            save_gimage.append(gen_samples)

        #pkl形式で画像を保存
        with open('save_gimage.pkl', 'wb') as f:
            pkl.dump(save_gimage, f)

        #各エポックで得た損失関数を値を保存
        with open('save_loss.pkl', 'wb') as f:
            pkl.dump(save_loss, f)

        #処理終了時刻の取得
        tstamp_e = dt.datetime.now().strftime("%H:%M:%S")

        time1 = dt.datetime.strptime(tstamp_s, "%H:%M:%S")
        time2 = dt.datetime.strptime(tstamp_e, "%H:%M:%S")

        #処理時間を表示
        print("開始:{0}, 終了:{1}, 処理時間:{2}".format(tstamp_s, \
            tstamp_e, (time2-time1)))

 ビュワープログラム

#ビュアープログラム
import sys
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import pickle as pkl

#エポック数(学習回数)
#gan_mnist.pyのEPOCHSと合わせておく
EPOCHS = 100

#画像の表示を行う
def display(fname):
    #画像ファイルの読み込み
    img  =Image.open(fname)
    #表示
    img.show()

#指定されたエポックにて、生成された画像の表示と保存を行う
#ep: エポック
#画像ファイルの出力と保存を行う
def result(ep):
    with open('save_gimage.pkl', 'rb') as f:
        #生成された画像を全件読み込む
        save_gimage = pkl.load(f)
        #generatorで一度に25枚の画像を生成するため
        #表示エリアに5*5のパネルを準備する
        fig, axes = plt.subplots(5, 5, figsize=(50, 50))

        #zipで表示する画像と表示位置を
        #対で取得し順に表示
        for img, ax in zip(save_gimage[ep], axes.flatten()):
            ax.xaxis.set_visible(False) #Xスケール非表示
            ax.yaxis.set_visible(False) #Yスケール非表示
            #画像はwidth=28, height=28のため、28*28に
            #リシェイし、グレースケール指定で画像化する
            ax.imshow(img.reshape(50, -1), vmin=-1, vmax=1, cmap='hsv')

        #epが-1のときは、学習最後の状態で生成された画像を対象にする
        if ep == -1:
            ep = EPOCHS-1

        #ファイル名編集
        fname = 'GANResult_' + format(ep, '03d')+'.png'
        print('file='+fname)
        #ファイル出力
        plt.savefig(fname)
        #ファイル表示
        display(fname)

#10エポックごとの生成画像を表示
#縦方向は10エポック単位,横方向は当該エポックで
#生成された25枚のうち、最初の五枚を表示
def history():
    with open('save_gimage.pkl', 'rb') as f:
        #エポックごとに生成された画像を全件読み込む
        save_gimage = pkl.load(f)

        #10エポックごとに5枚の生成画像を表示するエリアを設定する
        fig, axes = plt.subplots(int(EPOCHS/10), 5, figsize=(50,50))

        #10エポック単位に生成画像と表示位置を順に取得しながら処理を行う(縦)
        for save_gimage, ax_row in zip(save_gimage[::10], axes):
            #取り出したエポックには25枚の画像が含まれているため、
            #先頭から5枚の画像を順に取り出しパネルに並べる
            for img, ax in zip(save_gimage[::1], ax_row):
                #画像はwidth=28, height=28のため、28*28に
                #リシェイプし、グレースケール指定で画像化する
                ax.imshow(img.reshape(50, -1), vmin=-1, vmax=1, cmap='hsv')
                ax.xaxis.set_visible(False)
                ax.yaxis.set_visible(False)

        fname = 'GANHistroy.png'
        print('file=' + fname)
        plt.savefig(fname)
        display(fname)

#学習の経過をグラフ表示で確認する
def loss():
    with open('save_loss.pkl', 'rb') as f:
        save_loss = pkl.load(f)

        #学習損失の可視化
        fig, ax = plt.subplots()
        loss = np.array(save_loss)
        #転置しdiscriminatorのロスは0番目の要素から、
        #generatorのロスは1番目の要素から取得する
        plt.plot(loss.T[0], label='Discriminator')
        plt.plot(loss.T[1], label='Generator')
        plt.title('Loss')
        plt.legend()
        fname='GANLoss.png'
        print('file=' + fname)
        plt.savefig(fname)
        display(fname)

if __name__ == '__main__':
    args = sys.argv
    ep = 0

    if len(args) == 1:
        result(-1)
    elif args[1] == 'h':
        history()
        for i in range(0, EPOCHS-1, 10):
            result(i)
    elif args[1] == 'l':
        loss()
    else:
        result(int(args[1]))
  • 気になる質問をクリップする

    クリップした質問は、後からいつでもマイページで確認できます。

    またクリップした質問に回答があった際、通知やメールを受け取ることができます。

    クリップを取り消します

  • 良い質問の評価を上げる

    以下のような質問は評価を上げましょう

    • 質問内容が明確
    • 自分も答えを知りたい
    • 質問者以外のユーザにも役立つ

    評価が高い質問は、TOPページの「注目」タブのフィードに表示されやすくなります。

    質問の評価を上げたことを取り消します

  • 評価を下げられる数の上限に達しました

    評価を下げることができません

    • 1日5回まで評価を下げられます
    • 1日に1ユーザに対して2回まで評価を下げられます

    質問の評価を下げる

    teratailでは下記のような質問を「具体的に困っていることがない質問」、「サイトポリシーに違反する質問」と定義し、推奨していません。

    • プログラミングに関係のない質問
    • やってほしいことだけを記載した丸投げの質問
    • 問題・課題が含まれていない質問
    • 意図的に内容が抹消された質問
    • 広告と受け取られるような投稿

    評価が下がると、TOPページの「アクティブ」「注目」タブのフィードに表示されにくくなります。

    質問の評価を下げたことを取り消します

    この機能は開放されていません

    評価を下げる条件を満たしてません

    評価を下げる理由を選択してください

    詳細な説明はこちら

    上記に当てはまらず、質問内容が明確になっていない質問には「情報の追加・修正依頼」機能からコメントをしてください。

    質問の評価を下げる機能の利用条件

    この機能を利用するためには、以下の事項を行う必要があります。

まだ回答がついていません

同じタグがついた質問を見る

  • Python

    11198questions

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

  • 機械学習

    928questions

    機械学習は、データからパターンを自動的に発見し、そこから知能的な判断を下すためのコンピューターアルゴリズムを指します。人工知能における課題のひとつです。

  • TensorFlow

    888questions

  • NumPy

    617questions

    NumPyはPythonのプログラミング言語の科学的と数学的なコンピューティングに関する拡張モジュールです。

  • Matplotlib

    435questions

    MatplotlibはPythonのおよび、NumPy用のグラフ描画ライブラリです。多くの場合、IPythonと連携して使われます。