the_code/General/wgan_gp.py

# Following links were used to prepare this script. 
# https://github.com/keras-team/keras-contrib/blob/master/examples/improved_wgan.py
# https://github.com/igul222/improved_wgan_training
# https://arxiv.org/abs/1712.06148

from __future__ import print_function, division
import os
import errno
from keras.layers.merge import _Merge
from keras.layers import Input, Dense, Reshape, Flatten, add, Activation
from keras.layers.convolutional import Conv1D
from keras.models import Sequential, Model
from keras.optimizers import Adam
from functools import partial
import keras.backend as K
import numpy as np


BATCH_SIZE = 128
ITERS = 400001
SEQ_LEN = 500
SEQ_DIM = 4
DIM = 128
CRITIC_ITERS = 10
LAMBDA = 1
loginterval = 1000
seqinterval = 10000
modelinterval = 10000
selectedmodel = 400000
suffix = "generated"
ngenerate = 10
outputdirc = "./output/"
fastafile = "./data/KC_regions.fa"


for file in [outputdirc,
             os.path.join(outputdirc, 'models'),
             os.path.join(outputdirc, 'samples_ACGT'),
             os.path.join(outputdirc, 'samples_raw')]:
    try:
        os.makedirs(file)
    except OSError as exc:
        if exc.errno == errno.EEXIST:
            pass


def readfile(filename):
    ids = []
    seqs = []
    f = open(filename, 'r')
    lines = f.readlines()
    f.close()
    seq = []
    for line in lines:
        if line[0] == '>':
            ids.append(line[1:].rstrip('\n'))
            if seq != []: seqs.append("".join(seq))
            seq = []
        else:
            seq.append(line.rstrip('\n').upper())
    if seq != []:
        seqs.append("".join(seq))

    return ids, seqs


def one_hot_encode_along_row_axis(sequence):
    to_return = np.zeros((1, len(sequence), 4), dtype=np.int8)
    seq_to_one_hot_fill_in_array(zeros_array=to_return[0],
                                 sequence=sequence, one_hot_axis=1)
    return to_return


def seq_to_one_hot_fill_in_array(zeros_array, sequence, one_hot_axis):
    assert one_hot_axis == 0 or one_hot_axis == 1
    if one_hot_axis == 0:
        assert zeros_array.shape[1] == len(sequence)
    elif one_hot_axis == 1:
        assert zeros_array.shape[0] == len(sequence)
    for (i, char) in enumerate(sequence):
        if char == "A" or char == "a":
            char_idx = 0
        elif char == "C" or char == "c":
            char_idx = 1
        elif char == "G" or char == "g":
            char_idx = 2
        elif char == "T" or char == "t":
            char_idx = 3
        elif char == "N" or char == "n":
            continue
        else:
            raise RuntimeError("Unsupported character: "+str(char))
        if one_hot_axis == 0:
            zeros_array[char_idx, i] = 1
        elif one_hot_axis == 1:
            zeros_array[i, char_idx] = 1


class RandomWeightedAverage(_Merge):
    """Provides a (random) weighted average between real and generated image samples"""
    def _merge_function(self, inputs):
        alpha = K.random_uniform((BATCH_SIZE, 1, 1))
        return (alpha * inputs[0]) + ((1 - alpha) * inputs[1])


class WGANGP():
    def __init__(self):
        self.img_rows = SEQ_LEN
        self.img_cols = SEQ_DIM
        self.img_shape = (self.img_rows, self.img_cols)
        self.latent_dim = DIM

        # Following parameter and optimizer set as recommended in paper
        self.n_critic = CRITIC_ITERS
        optimizer = Adam(lr=1e-4, beta_1=0.5, beta_2=0.9)

        # Build the generator and critic
        self.generator = self.build_generator()
        self.critic = self.build_critic()

        # -------------------------------
        # Construct Computational Graph
        #       for the Critic
        # -------------------------------

        # Freeze generator's layers while training critic
        self.generator.trainable = False

        # Image input (real sample)
        real_img = Input(shape=self.img_shape)

        # Noise input
        z_disc = Input(shape=(DIM,))
        # Generate image based of noise (fake sample)
        fake_img = self.generator(z_disc)

        # Discriminator determines validity of the real and fake images
        fake = self.critic(fake_img)
        valid = self.critic(real_img)

        # Construct weighted average between real and fake images
        interpolated_img = RandomWeightedAverage()([real_img, fake_img])
        # Determine validity of weighted sample
        validity_interpolated = self.critic(interpolated_img)

        # Use Python partial to provide loss function with additional
        # 'averaged_samples' argument
        partial_gp_loss = partial(self.gradient_penalty_loss, averaged_samples=interpolated_img)
        partial_gp_loss.__name__ = 'gradient_penalty'  # Keras requires function names

        self.critic_model = Model(inputs=[real_img, z_disc],
                                  outputs=[valid, fake, validity_interpolated])
        self.critic_model.compile(loss=[self.wasserstein_loss, self.wasserstein_loss, partial_gp_loss],
                                  optimizer=optimizer,
                                  loss_weights=[1, 1, 10])

        # -------------------------------
        # Construct Computational Graph
        #         for Generator
        # -------------------------------

        # For the generator we freeze the critic's layers
        self.critic.trainable = False
        self.generator.trainable = True

        # Sampled noise for input to generator
        z_gen = Input(shape=(DIM,))
        # Generate images based of noise
        img = self.generator(z_gen)
        # Discriminator determines validity
        valid = self.critic(img)
        # Defines generator model
        self.generator_model = Model(z_gen, valid)
        self.generator_model.compile(loss=self.wasserstein_loss, optimizer=optimizer)

    def gradient_penalty_loss(self, y_true, y_pred, averaged_samples):
        """
        Computes gradient penalty based on prediction and weighted real / fake samples
        """
        gradients = K.gradients(y_pred, averaged_samples)[0]
        # compute the euclidean norm by squaring ...
        gradients_sqr = K.square(gradients)
        #   ... summing over the rows ...
        gradients_sqr_sum = K.sum(gradients_sqr,
                                  axis=np.arange(1, len(gradients_sqr.shape)))
        #   ... and sqrt
        gradient_l2_norm = K.sqrt(gradients_sqr_sum)
        # compute lambda * (1 - ||grad||)^2 still for each single sample
        gradient_penalty = LAMBDA * K.square(1 - gradient_l2_norm)
        # return the mean as loss over all the batch samples
        return K.mean(gradient_penalty)

    def wasserstein_loss(self, y_true, y_pred):
        return K.mean(y_true * y_pred)

    def res_cnn(self):
        input_tensor = Input(shape=(SEQ_LEN, DIM))
        x = Activation('relu')(input_tensor)
        x = Conv1D(DIM, 5, padding='same')(x)
        output = add([input_tensor, x])
        res_1d = Model(inputs=[input_tensor], outputs=[output])
        return res_1d

    def build_generator(self):
        model = Sequential()
        model.add(Dense(SEQ_LEN * DIM, activation='elu', input_shape=(DIM,)))
        model.add(Reshape((SEQ_LEN, DIM)))
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(Conv1D(SEQ_DIM, 1, padding='same'))
        model.add(Activation('softmax'))
        model.summary()
        noise = Input(shape=(self.latent_dim,))
        img = model(noise)
        return Model(noise, img)

    def build_critic(self):
        model = Sequential()
        model.add(Conv1D(DIM, 1, padding='same', input_shape=(SEQ_LEN, SEQ_DIM)))
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(self.res_cnn())
        model.add(Flatten())
        model.add(Dense(1))
        model.summary()
        img = Input(shape=self.img_shape)
        validity = model(img)
        return Model(img, validity)

    def train(self, foldername, filename, epochs, batch_size,
              log_interval=1000, seq_interval=10000, model_interval=10000):

        ids, seqs = readfile(filename)
        X_train = np.array([one_hot_encode_along_row_axis(seq) for seq in seqs]).squeeze(axis=1)

        # Adversarial ground truths
        valid = -np.ones((batch_size, 1))
        fake = np.ones((batch_size, 1))
        dummy = np.zeros((batch_size, 1))

        disc_json = self.critic_model.to_json()
        with open(foldername + '/disc.json', "w") as disc_json_file:
            disc_json_file.write(disc_json)

        gen_json = self.generator_model.to_json()
        with open(foldername + '/gen.json', "w") as gen_json_file:
            gen_json_file.write(gen_json)
            
        d_loss_list = []
        g_loss_list = []
        for epoch in range(epochs):
            for _ in range(self.n_critic):
                # ---------------------
                #  Train Discriminator
                # ---------------------
                # Select a random batch of images
                idx = np.random.randint(0, X_train.shape[0], batch_size)
                imgs = X_train[idx]
                # Sample generator input
                noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
                # Train the critic
                d_loss = self.critic_model.train_on_batch([imgs, noise],
                                                          [valid, fake, dummy])
            # ---------------------
            #  Train Generator
            # ---------------------
            g_loss = self.generator_model.train_on_batch(noise, valid)

            if epoch % log_interval == 0:
                d_loss_list.append(d_loss)
                g_loss_list.append(g_loss)

            if epoch % seq_interval == 0:
                samples = []
                for i in range(1):
                    samples.extend(self.generate_samples())
                with open(foldername + '/samples_ACGT/samples_ACGT_{}.fa'.format(epoch), 'w') as f:
                    for line_number, s in enumerate(samples[0]):
                        f.write(">" + str(line_number+1) + "\n")
                        s = "".join(s)
                        f.write(s + "\n")
                with open((foldername + '/samples_raw/samples_{}.txt').format(epoch), 'w') as f2:
                    print(samples[1], file=f2)

            if epoch % model_interval == 0:
                self.critic_model.save_weights(foldername + '/models/disc_{}.hdf5'.format(epoch))
                self.critic_model.save(foldername + '/models/disc_{}.h5'.format(epoch))
                self.generator_model.save_weights(foldername + '/models/gen_{}.hdf5'.format(epoch))
                self.generator_model.save(foldername + '/models/gen_{}.h5'.format(epoch))
        
        
        import pickle
        f = open(foldername + '/d_g_loss.pkl', "wb")
        pickle.dump(d_loss_list,f)
        pickle.dump(g_loss_list,f)
        f.close()
        

    def generate_samples(self):
        char_ACGT={0:'A' , 1:'C' , 2:'G' , 3:'T'}
        noise = np.random.normal(0, 1, (BATCH_SIZE, self.latent_dim))
        gen_imgs = self.generator.predict(noise)
        samples = np.argmax(gen_imgs, axis=2)
        decoded_samples = []
        for i in range(len(samples)):
            decoded = ''
            for j in range(len(samples[i])):
                decoded += char_ACGT[samples[i][j]]
            decoded_samples.append(decoded)
        return decoded_samples, gen_imgs

    def generate(self, nb=1, model_number=0, result_number=0):
        hdf5_filename = outputdirc + "/models/disc_" + str(model_number) + ".hdf5"
        self.generator_model.load_weights(hdf5_filename)
        samples = []
        for i in range(nb):
            samples.extend(self.generate_samples()[0])
        with open(outputdirc + '/gen_seq/generated_{}_iter_{}.fa'.format(nb*BATCH_SIZE, model_number), 'w') as f:
            counter = 0
            for s in samples:
                counter += 1
                s = "".join(s)
                f.write(">" + str(counter) + "_" + str(result_number) + "_" + str(model_number) + "\n" + s + "\n")


if __name__ == '__main__':
    wgan = WGANGP()
    # Train the model
    wgan.train(outputdirc, fastafile, epochs=ITERS, batch_size=BATCH_SIZE,
               log_interval=loginterval, seq_interval=seqinterval, model_interval=modelinterval)
    
    # Generate sequences after training
    try:
        os.makedirs(os.path.join(outputdirc, 'gen_seq'))
    except OSError as exc:
        if exc.errno == errno.EEXIST:
            pass
    for i in range(0, selectedmodel+1, modelinterval):
        wgan.generate(nb=ngenerate, model_number=i, result_number=suffix)