added model code and removed unused imports

import os

from flair.data import Sentence

from flair.embeddings import BertEmbeddings,WordEmbeddings,StackedEmbeddings

from keras_self_attention import SeqSelfAttention, SeqWeightedAttention, ScaledDotProductAttention

from copy import deepcopy

from sklearn.utils.class_weight import compute_sample_weight

from statistics import mode

from keras import optimizers

import sys

import json

import numpy as np

from keras.layers import Embedding, Input, Dense, Bidirectional, LSTM, Concatenate, Add, Multiply,Flatten

from keras.models import Model,load_model

from scipy.stats import pearsonr

from sklearn.metrics import accuracy_score,f1_score,precision_score,recall_score

from sklearn.metrics import cohen_kappa_score

from random import shuffle

import pickle

from collections import defaultdict

import argparse

from numpy.random import seed

from eval_helpers import evaluate, extensive_evaluate,extensive_evaluate_regression,evaluate_regression

#print("gpus",K.tensorflow_backend._get_available_gpus())

from config import *

from copy import deepcopy

from keras_self_attention import SeqSelfAttention

from keras import optimizers

from keras.layers import Embedding, Input, Dense, Bidirectional, LSTM, Concatenate, Add, Multiply,Flatten

from keras.models import Model,load_model

class ModelConstructor():

    def __init__(self, HIER=True,LENGTH=30,AUXREG=True,SOFTMAX=True,ATT=True,MARKER_1=True,MARKER_2=False,EMBEDDING_DIM=868,NPOINTERS=4,LSTMUNITS=64,NCLASSES=18):

        self.HIER=HIER

        self.LENGTH = LENGTH

        self.AUXREG = AUXREG

        self.SOFTMAX = SOFTMAX

        self.ATT = ATT

        self.MARKER_1=MARKER_1

        self.MARKER_2=MARKER_2

        self.EMBEDDING_DIM = EMBEDDING_DIM

        self.NPOINTERS = 4

        self.LSTMUNITS=LSTMUNITS

        self.NCLASSES = NCLASSES

        return None

    def make_model(self):

        ep = Embedding(self.NPOINTERS, self.EMBEDDING_DIM, trainable=True)

        ep2 = Embedding(self.NPOINTERS, self.EMBEDDING_DIM, trainable=True)

        inw =  Input((self.LENGTH,self.EMBEDDING_DIM))

        inp =  Input((self.LENGTH,))

        lstm = Bidirectional(LSTM(self.LSTMUNITS, return_sequences=True))

        embedded_words = inw

        embedded_ptrs = ep(inp)

        if self.MARKER_1:

            embedded=Multiply()([embedded_words,embedded_ptrs])

        embedded=lstm(embedded)

        if self.ATT:

            sa = SeqSelfAttention(attention_activation='sigmoid')

            embedded=sa(embedded)

        embedded=Flatten()(embedded)

        if self.MARKER_2:

            ep2 = Flatten()(ep2(inp))

            embedded=Multiply()([embedded,ep2])

        outlayers = []

        for i in range(self.NCLASSES):

            if self.AUXREG:

                outlayers.append(Dense(1,activation="relu"))

            else:

                outlayers.append(Dense(2,activation="softmax"))

        auxoutputs=[f(embedded) for f in outlayers]

        if self.HIER:

            combined = Concatenate()(auxoutputs+[embedded])

        else:

            combined = embedded

        outlayersmain = []

        if self.SOFTMAX:

            for i in range(self.NCLASSES):

                outlayersmain.append(Dense(2,activation="softmax"))

        else:

            for i in range(self.NCLASSES):

                outlayersmain.append(Dense(1,activation="relu"))

        outputs=[f(combined) for f in outlayersmain]

        model = Model(inputs=[inw,inp], outputs=outputs+auxoutputs)

        optim=optimizers.Adam()

        losses = ['categorical_crossentropy' for i in range(self.NCLASSES)]+['mean_squared_error' for i in range(self.NCLASSES)]

        if not self.SOFTMAX:

            losses = ['mean_squared_error' for i in range(self.NCLASSES)]+['mean_squared_error' for i in range(self.NCLASSES)]

        model.compile(optimizer=optim, loss=losses,loss_weights=[1.0]*self.NCLASSES+[0.2]*self.NCLASSES)

        print(model.summary())

        return model