Fighter の射程（fighter.firing_range）
SAM の位置（sam.offset）
SAM の射程（sam.firing_range）
ジャミングを受けた時の SAM の射程（sam.jammed_firing_range）

fighter.ingress
jammer.ingress

    - Generator Input
        + 正規分布からのサンプル z ~ N(0, I)
    - Generator Output:２出力
        + ミッション・プランを正規化したもの
            * Jammer.ingress（進出レンジ）/sam.max_offset
            * Fighter.ingress（進出レンジ）/sam.max_offset
            * (Jammet と Fighter のタイミングについてのプランは生成しません。これは、レポートも同じです。私が、step_by_step のシミュレーションを実装しなかった理由はここです)。

    - Discriminator Input：2入力
        + Generator が生成した Fake のミッションプラン、または、シミュレーション結果である True のミッションプラン（正例のみ使用）
    - Discriminato Output
        + Fake/True の確率

    -　Condition 入力：4入力 
        + ミッション条件を正規化したもの
            * Fighter の射程 = fighter.firing_range/fighter.max_firing_range
            * SAM 配備位置 = sam.offset / sam.max_offset
            * SAMの 射程 = sam.firing_range / sam.max_firing_range
            * ジャミングを受けた時の SAM の射程 = sam.firing_range * .7 / sam.max_firing_range

"""
Train the GAN
"""
while True:
    epoch += 1
    print(f'Current epoch = {epoch}')
    d_loss = 0
    g_loss = 0
    d_accuracy = 0
    g_accuracy = 0

    for (X_batch, y_batch) in dataset:
        # データの型を変換
        X_batch = tf.cast(X_batch, tf.float32)
        y_batch = tf.cast(y_batch, tf.float32)

        """
        Train the discriminator
        """
        discriminator.trainable = True
        generator.trainable = False

        # Sample from N(0,1)
        z = np.random.randn(batch_size, coding_size)  # (256,100)
        gen_images = generator([z, y_batch])  # (256,2), float32

        # Make the dataset for the training
        X_fake_vs_real = tf.concat([gen_images, X_batch], axis=0)  # (512,2)
        y_fake_vs_real = \
            tf.concat([tf.zeros(batch_size), tf.ones(batch_size)], axis=0)  # (512,)
        y_fake_vs_real = tf.expand_dims(y_fake_vs_real, axis=1)  # (512,1)
        cond_label = tf.concat([y_batch, y_batch], axis=0)  # (512,5)

        # Train the discriminator
        d = discriminator.fit(x=[X_fake_vs_real, cond_label], y=y_fake_vs_real, epochs=1, verbose=0)
        d_loss += d.history['loss'][0]
        d_accuracy += d.history['accuracy'][0]

        """
        Train the generator
        """
        discriminator.trainable = False
        generator.trainable = True

        # Sample from N(0,1)
        noise = np.random.randn(batch_size, coding_size)  # (256,100)
        lab = y_batch
        y_gen = tf.ones(batch_size)  # (256,)
        y_gen = tf.expand_dims(y_gen, axis=1)  # (256,1)

        # Train the generator
        g = gan.fit(x=[noise, lab], y=y_gen, epochs=1, verbose=0)
        g_loss += g.history['loss'][0]
        g_accuracy += g.history['accuracy'][0]

class GAN(object):
    """
    GANを定義
    """

    def __init__(self, coding_size):
        self.coding_size = coding_size
        self.action_size = 2
        self.condition_size = 4

    def create_generator(self):
        """
        Define the Generator
        """
        g1 = Input(shape=(self.coding_size,))  # (None,100)
        c1 = Input(shape=(self.condition_size,))  # (None,5)
        cond_in = Concatenate(axis=-1)([g1, c1])  # (None,105)

        g2 = Dense(units=HIDDEN_UNITS, activation='relu')(cond_in)  # (None,128)
        g3 = BatchNormalization()(g2)  # (None,128)
        g4 = Dense(units=HIDDEN_UNITS, activation='relu')(g3)  # (None,128)
        # g5 = Dense(units=self.action_size, activation='linear')(g4)  # (None,2)
        g5 = Dense(units=self.action_size, activation=FINAL_ACTIVATION)(g4)  # (None,2)

        generator = Model([g1, c1], g5, name='generator')
        return generator

    def create_discriminator(self):
        """
        Define the Discriminator
        """
        d1 = Input(shape=(self.action_size,))  # (None,2)
        c1 = Input(shape=(self.condition_size,))  # (None,5)
        cond_in = Concatenate(axis=-1)([d1, c1])
        d2 = Dense(units=HIDDEN_UNITS, activation='relu')(cond_in)  # (None,128)
        d3 = Dropout(rate=0.5)(d2)  # (None,128)
        d4 = Dense(units=HIDDEN_UNITS, activation='relu')(d3)  # (None,128)
        d5 = Dense(units=1, activation='sigmoid')(d4)  # (None,1)

        discriminator = Model([d1, c1], d5, name='discriminator')
        return discriminator

    def create_gan(self):
        # Create the Generator
        generator = self.create_generator()

        # Create the Discriminator
        discriminator = self.create_discriminator()
        optimizer = Adam(learning_rate=DISCRIMINATOR_LR)
        discriminator.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])

        # Create the GAN
        noise_input = Input(shape=(self.coding_size,))  # (None,100)
        cond_input = Input(shape=(self.condition_size,))  # (None,5)
        f_image = generator([noise_input, cond_input])  # (None,2)
        gan_output = discriminator([f_image, cond_input])  # (None,1)

        gan = Model([noise_input, cond_input], gan_output, name='gan')
        optimizer = Adam(learning_rate=GAN_LR)
        gan.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])

        return gan, generator, discriminator