2. 多視角圖像生成

s3dis數據集包含了大量的高質量渲染圖像，這為多視角圖像生成提供了有力支撐。下面，我們通過使用s3dis數據集中的渲染圖像，訓練一個GAN網絡來生成室內場景中的多視角圖像。

## 定義GAN網絡結構
def generator(inputs, is_training):
    # todo: add generator network
    return gen_output

def discriminator(inputs, is_training):
    # todo: add discriminator network
    return dis_output

## 數據讀取
def load_data(data_dir):
    # todo: load s3dis data
    return data, label, imgs

if __name__ == '__main__':
    data_dir = 'data/s3dis'
    model_dir = 'model/s3dis'
    if not os.path.exists(model_dir):
        os.makedirs(model_dir)

    tf.reset_default_graph()
    z_ph = tf.placeholder(tf.float32, shape=(32, 100))
    img_ph = tf.placeholder(tf.float32, shape=(32, 224, 224, 3))
    is_training = tf.placeholder(tf.bool, shape=())

    ## 定義GAN網絡
    gen_output = generator(z_ph, is_training=is_training)
    dis_real = discriminator(img_ph, is_training=is_training)
    dis_fake = discriminator(gen_output, is_training=is_training, reuse=True)

    ## 定義損失函數
    d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=dis_real, labels=tf.ones_like(dis_real)))
    d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=dis_fake, labels=tf.zeros_like(dis_fake)))
    d_loss = d_loss_real + d_loss_fake

    g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=dis_fake, labels=tf.ones_like(dis_fake)))

    tf.summary.scalar("d_loss", d_loss)
    tf.summary.scalar("g_loss", g_loss)

    ## 定義優(yōu)化器
    gen_vars = [var for var in tf.trainable_variables() if 'Generator' in var.name]
    dis_vars = [var for var in tf.trainable_variables() if 'Discriminator' in var.name]

    gan_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4)
    dis_optimizer = tf.train.AdamOptimizer(learning_rate=2e-4)
    gen_optimizer = tf.train.AdamOptimizer(learning_rate=2e-4)

    gan_train = gan_optimizer.minimize(g_loss, var_list=gen_vars, global_step=tf.train.get_global_step())
    dis_train = dis_optimizer.minimize(d_loss, var_list=dis_vars, global_step=tf.train.get_global_step())
    gen_train = gen_optimizer.minimize(g_loss, var_list=gen_vars, global_step=tf.train.get_global_step())

    saver = tf.train.Saver()

    ## 數據讀取
    data, label, imgs = load_data(data_dir)
    num_data = data.shape[0]

    ## 開始訓練
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        file_writer = tf.summary.FileWriter('logs', sess.graph)
        merged_summary_op = tf.summary.merge_all()

        for epoch in range(max_epoch):
            idx = np.arange(num_data)
            np.random.shuffle(idx)
            total_d_loss, total_g_loss = 0, 0

            ## 按批次進行訓練
            for from_idx in range(0, num_data, batch_size):
                to_idx = min(from_idx + batch_size, num_data)
                batch_z = np.random.normal(size=[batch_size, 100])

                ## 訓練判別器
                _, batch_d_loss, summary = sess.run([dis_train, d_loss, merged_summary_op], feed_dict={
                    z_ph: batch_z,
                    img_ph: imgs[idx[from_idx:to_idx]],
                    is_training: True
                })
                total_d_loss += batch_d_loss

                ## 訓練生成器
                _, batch_g_loss, summary = sess.run([gen_train, g_loss, merged_summary_op], feed_dict={
                    z_ph: batch_z,
                    is_training: True
                })
                total_g_loss += batch_g_loss

            print('Epoch %d, d_loss %.4f, g_loss %.4f' % (epoch, total_d_loss, total_g_loss))

            ## 每十個epoch保存一次模型
            if epoch % 10 == 0:
                saver.save(sess, os.path.join(model_dir, 'model.ckpt'), global_step=epoch)

import numpy as np
import tensorflow as tf
import os
import sys
import time

## 定義DQN網絡結構
def DQN(state_ph, action_ph, is_training):
    # todo: add DQN network
    return Q

## 數據讀取
def load_data(data_dir):
    # todo: load s3dis data
    return data, label, nav_path

if __name__ == '__main__':
    data_dir = 'data/s3dis'
    model_dir = 'model/s3dis'
    if not os.path.exists(model_dir):
        os.makedirs(model_dir)

    tf.reset_default_graph()
    state_ph = tf.placeholder(tf.float32, shape=(None, 4096, 6))
    action_ph = tf.placeholder(tf.int32, shape=(None,))
    is_training = tf.placeholder(tf.bool, shape=())

    ## 定義DQN網絡
    Q = DQN(state_ph, action_ph, is_training=is_training)

    ## 定義損失函數和優(yōu)化器
    target_ph = tf.placeholder(tf.float32, shape=(None,))
    action_one_hot = tf.one_hot(action_ph, num_action)
    Q_pred = tf.reduce_sum(tf.multiply(Q, action_one_hot), axis=1)
    loss = tf.reduce_mean(tf.square(Q_pred - target_ph))
    optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)
    train_op = optimizer.minimize(loss)

    saver = tf.train.Saver()

    ## 數據讀取
    data, label, nav_path = load_data(data_dir)
    num_data = data.shape[0]

    ## 開始訓練
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        file_writer = tf.summary.FileWriter('logs', sess.graph)

        for epoch in range(max_epoch):
            idx = np.arange(num_data)
            np.random.shuffle(idx)
            total_loss = 0

            ## 按批次進行訓練
            for from_idx in range(0, num_data, batch_size):
                to_idx = min(from_idx + batch_size, num_data)
                batch_data = data[idx[from_idx:to_idx], :, :]
                batch_nav_path = nav_path[idx[from_idx:to_idx], :, :]

                ## 訓練一個批次
                Q_pred_ = sess.run(Q, feed_dict={
                    state_ph: batch_data,
                    is_training: False
                })

                ## 以一定的概率采取隨機