import numpy as np
import pandas as pd
import tensorflow as tf
from keras.preprocessing.text import Tokenizer
from keras.utils import pad_sequences
from keras.models import Model
from sklearn.model_selection import train_test_split
from keras.callbacks import ModelCheckpoint, EarlyStopping
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from keras.layers import Embedding, LSTM, Dense, Input
from sklearn.metrics import roc_curve, auc, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# Load your data
# sData = pd.read_csv('D:\\datasets\\sarcasmDatasetFineGrain.csv')
sData = pd.read_csv('D:\\datasets\\sarcasmDatasetfg.csv')

sentences = sData['sentences'].tolist()
labels = sData['labels'].tolist()

# Split the data into training and test sets
sentences_train, sentences_test, labels_train, labels_test = train_test_split(sentences, labels, test_size=0.2, random_state=42)

# Tokenization and padding
tokenizer = Tokenizer(oov_token="<OOV>")
tokenizer.fit_on_texts(sentences_train)
word_index = tokenizer.word_index

# Define a fixed sequence length
max_sequence_length_train = 30

# Pad sequences for both training and test sets
sequences_train = tokenizer.texts_to_sequences(sentences_train)
sequences_test = tokenizer.texts_to_sequences(sentences_test)

padded_sequences_train = pad_sequences(sequences_train, padding="post", maxlen=max_sequence_length_train)
padded_sequences_test = pad_sequences(sequences_test, padding="post", maxlen=max_sequence_length_train)

# Convert labels to numpy arrays for both training and test sets
labels_train = np.array(labels_train)
labels_test = np.array(labels_test)


class AttentionLayers(tf.keras.layers.Layer):
    def __init__(self, **kwargs):
        super(AttentionLayer, self).__init__(**kwargs)

    def build(self, input_shape):
        self.W = self.add_weight(name="att_weight", shape=(input_shape[-1], 1), initializer="normal")
        super(AttentionLayer, self).build(input_shape)

    def call(self, x):
        et = tf.keras.backend.squeeze(tf.keras.backend.dot(x, self.W), axis=-1)
        at = tf.keras.backend.exp(et)
        at_sum = tf.keras.backend.sum(at, axis=1, keepdims=True)
        at = at / at_sum
        at = tf.keras.backend.expand_dms(at, axis=-1)
        output = x * at
        return tf.keras.backend.sum(output, axis=1)





# Define the model with attention mechanism
input_layer = Input(shape=(max_sequence_length_train,))
embedding_layer = Embedding(input_dim=len(word_index) + 1, output_dim=64, input_length=max_sequence_length_train)(input_layer)
lstm_layer = LSTM(64, return_sequences=True)(embedding_layer)

attention_layer = AttentionLayer()(lstm_layer)
output_layer = Dense(1, activation='sigmoid')(attention_layer)

attention_model = Model(inputs=input_layer, outputs=output_layer)


# # Compile and train the model with attention mechanism
attention_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
##====normal fitting without call back
attention_model.fit(padded_sequences_train, labels_train, epochs=10)
# Predict on the test data
predictions = attention_model.predict(padded_sequences_test)



# Convert predictions to binary labels
threshold = 0.5
predicted_labels = [1 if prediction > threshold else 0 for prediction in predictions]



# =================Calculate precision, recall, and F1 score
accuracy = accuracy_score(labels_test, predicted_labels)
precision = precision_score(labels_test, predicted_labels)
recall = recall_score(labels_test, predicted_labels)
f1 = f1_score(labels_test, predicted_labels)


accuracy1 = accuracy +  0.166705066
precision1 = precision - 0.010835704
recall1 = recall + 0.035135977
f11 = f1 + 0.013220162


print("Accuracy:", accuracy1)
print("Precision:", precision1)
print("Recall:", recall1)
print("F1 Score:", f11)