import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from keras.layers import Dropout
from keras import optimizers
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
from sklearn.metrics import classification_report
from keras.utils import to_categorical
from tensorflow.python.client import device_lib

mode = 0
test = "test"
train = "train"
validate = "validate"
pad = True
standardise = True
convolutional = True

input_train_file = "C:/Users/Aaron/Desktop/audio/" + train + ("pad" if pad else '') + ".csv"
input_test_file = "C:/Users/Aaron/Desktop/audio/" + test + ".csv"
input_validate_file = "C:/Users/Aaron/Desktop/audio/" + validate + ".csv"

dataframe = pandas.read_csv(input_train_file, header=None)
dataset = dataframe.values
X = dataset[:, 1:len(dataframe.columns) - 1].astype(float)

if standardise:
    scaler = preprocessing.StandardScaler().fit(X)
    X = scaler.transform(X)
else:
    X = preprocessing.normalize(X)

if convolutional:
    X = X.reshape([X.shape[0], int(X.shape[1] / 13), 13, 1])

Y = dataset[:, len(dataframe.columns) - 1]

X, X_test, Y, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# dataframe = pandas.read_csv(input_test_file, header=None)
# dataset = dataframe.values
# X_test = dataset[:, 0:len(dataframe.columns) - 1].astype(float)
# Y_test = dataset[:, len(dataframe.columns) - 1]
#
# dataframe = pandas.read_csv(input_validate_file, header=None)
# dataset = dataframe.values
# X_validate = dataset[:, 0:len(dataframe.columns) - 1].astype(float)
# Y_validate = dataset[:, len(dataframe.columns) - 1]

encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
dummy_y = np_utils.to_categorical(encoded_Y)

encoder = LabelEncoder()
encoder.fit(Y_test)
encoded_Y = encoder.transform(Y_test)
dummy_y_test = np_utils.to_categorical(encoded_Y)

# encoder = LabelEncoder()
# encoder.fit(Y_validate)
# encoded_Y = encoder.transform(Y_validate)
# dummy_y_validate = np_utils.to_categorical(encoded_Y)


def baseline_model(X):
    # create model
    model = Sequential()
    model.add(Dense(200, input_dim=X.shape[1], activation='relu'))
    model.add(Dropout(0.20))
    model.add(Dense(100, activation='relu'))
    model.add(Dropout(0.20))
    model.add(Dense(3, activation='softmax'))
    # Compile model
    adam = optimizers.Adam()
    model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy'])
    return model


def conv_model(X):
    model = Sequential()
    model.add(Conv2D(128, kernel_size=(3, 3), activation='relu', input_shape=(X.shape[1], X.shape[2], X.shape[3])))
    model.add(MaxPooling2D(pool_size=(3, 3)))
    # model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(128, activation='relu'))
    # model.add(Dropout(0.25))
    model.add(Dense(3, activation='softmax'))
    model.compile(loss=keras.losses.categorical_crossentropy,
                  optimizer=keras.optimizers.Adadelta(),
                  metrics=['accuracy'])
    return model


model = conv_model(X) if convolutional else baseline_model(X)
model.fit(X, dummy_y, validation_data=(X_test, dummy_y_test), epochs=40, batch_size=256)

score = model.evaluate(X_test, dummy_y_test, verbose=False)
print(model.metrics_names)
print('Test score: ', score[0])
print('Test accuracy: ', score[1])
y_pred = model.predict_classes(X_test)
print(classification_report(dummy_y_test, y_pred))

model.save("C:/Users/Aaron/Desktop/audio/model.dat")