import pandas as pd
import numpy as np

train_url = "https://github.com/PhilChodrow/PIC16b/blob/master/datasets/fake_news_train.csv?raw=true"
df = pd.read_csv(train_url, header=0, index_col=0)

df.groupby("fake").size()

# Import stopwords with nltk.
import nltk
nltk.download('stopwords')

from nltk.corpus import stopwords
stop = stopwords.words('english')

def rm_stop_words(x: list) -> list:
    wd_list = [word for word in x.split() if word not in (stop) + list('abcdefghijklmnopqrstuvwxyz')]
    return ' '.join(wd_list)

import tensorflow as tf

def make_dataset(df: pd.DataFrame) -> tf.data.Dataset:
    """
    Create new columns by removing the prior words
    Create a Tensorflow Dataset object from the pandas Dataframe
    Shuffle and Batch the Dataset object
    """

    # Applying the previously defined function
    df['text_wo_stop'] = df['text'].apply(rm_stop_words)
    df['title_wo_stop'] = df['text'].apply(rm_stop_words)
    data = tf.data.Dataset.from_tensor_slices(
        (
            {
                "title" : df[["title_wo_stop"]], 
                "text" : df[["text_wo_stop"]]
            }, 
            {
                "fake" : df[["fake"]]
            }
        )
    )

    # We wish to shuffle the dataset
    data = data.shuffle(buffer_size = len(data))

    # Using the batch function we group entries
    batch = data.batch(20)

    return batch
dataset = make_dataset(df)

DATASET_SIZE = len(dataset)
train_size = int(0.8 * DATASET_SIZE)
val_size = int(0.2 * DATASET_SIZE)

train_dataset = dataset.take(train_size)
val_dataset = dataset.take(val_size)

import string
import re

from tensorflow.keras.layers.experimental.preprocessing import TextVectorization
from tensorflow.keras import Input, layers, Model, utils, losses

size_vocabulary = 2000

def standardization(input_data):
    lowercase = tf.strings.lower(input_data)
    no_punctuation = tf.strings.regex_replace(lowercase, 
                                              f"[{re.escape(string.punctuation)}]",
                                              '')
    
    return no_punctuation 

vectorize_layer = TextVectorization(
    standardize=standardization,
    max_tokens=size_vocabulary, # only consider this many words
    output_mode='int',
    output_sequence_length=500) 

vectorize_layer.adapt(train_dataset.map(lambda x, y: x["text"]))

# shared embedding layer

embedding = layers.Embedding(size_vocabulary, 3, name = "embedding")

text_input = Input(shape = (1,), name = "text", dtype = "string")

# Text Embedding
text_features = vectorize_layer(text_input)
text_features = embedding(text_features)

# Normal Network Architecture
text_features = layers.Dropout(0.2)(text_features)
text_features = layers.GlobalAveragePooling1D()(text_features)
text_features = layers.Dropout(0.2)(text_features)
text_features = layers.Dense(32, activation='relu')(text_features)
output = layers.Dense(1, name = "fake")(text_features)

text_model = Model(
   inputs = [text_input],
   outputs = output
)
text_model.compile(optimizer = "adam",
                   loss = losses.BinaryCrossentropy(from_logits=True),
                   metrics=['accuracy']
)

history = text_model.fit(train_dataset, 
                         validation_data=val_dataset,
                         epochs = 10,
                         callbacks=tf.keras.callbacks.EarlyStopping(patience=2))

visualize_history(history)

title_input = Input(shape = (1,), name = "title", dtype = "string")

# Text Embedding
title_features = vectorize_layer(title_input)
title_features = embedding(title_features)

# Normal Network Architecture
title_features = layers.Dropout(0.2)(title_features)
title_features = layers.GlobalAveragePooling1D()(title_features)
title_features = layers.Dropout(0.2)(title_features)
title_features = layers.Dense(32, activation='relu')(title_features)
output = layers.Dense(1, name = "fake")(title_features)

title_model = Model(
   inputs = [title_input],
   outputs = output
)
title_model.compile(optimizer = "adam",
                   loss = losses.BinaryCrossentropy(from_logits=True),
                   metrics=['accuracy']
)

history = title_model.fit(train_dataset, 
                         validation_data=val_dataset,
                         epochs = 10,
                         callbacks=tf.keras.callbacks.EarlyStopping(patience=2))

visualize_history(history)

combined_features = layers.concatenate([text_features, title_features], axis = 1)
combined_features = layers.Dense(10)(combined_features)
output = layers.Dense(1, name = "fake")(combined_features)

both_model = Model(
   inputs = [text_input, title_input],
   outputs = output
)

both_model.compile(optimizer = "adam",
                   loss = losses.BinaryCrossentropy(from_logits=True),
                   metrics=['accuracy']
)

history = both_model.fit(train_dataset, 
                         validation_data=val_dataset,
                         epochs = 50,
                         callbacks=tf.keras.callbacks.EarlyStopping(patience=5))

visualize_history(history)

test_url = "https://github.com/PhilChodrow/PIC16b/blob/master/datasets/fake_news_test.csv?raw=true"
test_df = pd.read_csv(test_url)
test_dataset = make_dataset(test_df)
both_model.evaluate(test_dataset)

weights = both_model.get_layer('embedding').get_weights()[0] # get the weights from the embedding layer
vocab = vectorize_layer.get_vocabulary()                # get the vocabulary from our data prep for later

from sklearn.decomposition import PCA
pca = PCA(n_components=2)
weights = pca.fit_transform(weights)

embedding_df = pd.DataFrame({
    'word' : vocab, 
    'x0'   : weights[:,0],
    'x1'   : weights[:,1]
})

import plotly.express as px 
fig = px.scatter(embedding_df, 
                 x = "x0", 
                 y = "x1", 
                 size = list(np.ones(len(embedding_df))),
                 size_max = 2,
                 hover_name = "word")

fig.show()

feminine = ["she", "her", "woman"]
masculine = ["he", "him", "man"]

highlight_1 = ["strong", "powerful", "smart",     "thinking"]
highlight_2 = ["hot",    "sexy",     "beautiful", "shopping"]

def gender_mapper(x):
    if x in feminine:
        return 1
    elif x in masculine:
        return 4
    elif x in highlight_1:
        return 3
    elif x in highlight_2:
        return 2
    else:
        return 0

embedding_df["highlight"] = embedding_df["word"].apply(gender_mapper)
embedding_df["size"]      = np.array(1.0 + 50*(embedding_df["highlight"] > 0))

import plotly.express as px 

fig = px.scatter(embedding_df, 
                 x = "x0", 
                 y = "x1", 
                 color = "highlight",
                 size = list(embedding_df["size"]),
                 size_max = 10,
                 hover_name = "word")

fig.show()