"""Train small GloVe vectors, then test them in an IMDb classifier.
Run: python keras_glove_imdb.py
Install: pip install tensorflow keras numpy scikit-learn matplotlib
This teaching run uses a subset of TRAINING reviews for co-occurrence counts.
"""
from collections import Counter

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import keras
from keras import layers, ops
from keras.datasets import imdb
from keras.utils import pad_sequences
from sklearn.metrics import ConfusionMatrixDisplay, classification_report, confusion_matrix
from sklearn.model_selection import train_test_split

SEED = 42
VOCAB = 3000
DIM = 50
LENGTH = 160
WINDOW = 2
keras.utils.set_random_seed(SEED)

(train_reviews, train_labels), (test_reviews, test_labels) = imdb.load_data(
    num_words=VOCAB, seed=SEED)
train_ids, val_ids = train_test_split(
    np.arange(len(train_reviews)), test_size=5000, random_state=SEED,
    stratify=train_labels)
X_train = pad_sequences([train_reviews[i] for i in train_ids], maxlen=LENGTH,
                        padding="post", truncating="pre")
X_val = pad_sequences([train_reviews[i] for i in val_ids], maxlen=LENGTH,
                      padding="post", truncating="pre")
X_test = pad_sequences(test_reviews, maxlen=LENGTH, padding="post",
                       truncating="pre")
y_train = np.asarray(train_labels)[train_ids]
y_val = np.asarray(train_labels)[val_ids]
y_test = np.asarray(test_labels)

# Count local context across training text only. IDs 0, 1, 2 are special.
counts = Counter()
for review in X_train[:1200]:  # bounded so the first run stays approachable
    words = [int(w) for w in review if 2 < w < VOCAB]
    for position, center in enumerate(words):
        for offset in range(-WINDOW, WINDOW + 1):
            neighbor = position + offset
            if offset and 0 <= neighbor < len(words):
                counts[(center, words[neighbor])] += 1 / abs(offset)
print("Nonzero co-occurrence cells:", len(counts))

# X_ij is sparse: train only on observed pairs, never on zero counts.
items = counts.most_common(120000)
ids_i = np.asarray([pair[0][0] for pair in items], dtype="int32")
ids_j = np.asarray([pair[0][1] for pair in items], dtype="int32")
values = np.asarray([pair[1] for pair in items], dtype="float32")
target_log_count = np.log(values).reshape(-1, 1)
weights = np.minimum((values / 100.0) ** 0.75, 1.0)
perm = np.random.default_rng(SEED).permutation(len(values))
cut = max(1, round(0.1 * len(values)))
fit_ids, holdout_ids = perm[cut:], perm[:cut]

word_id = keras.Input(shape=(), dtype="int32")
context_id = keras.Input(shape=(), dtype="int32")
word_vectors = layers.Embedding(VOCAB, DIM, name="word_vectors")
context_vectors = layers.Embedding(VOCAB, DIM, name="context_vectors")
word_bias = layers.Embedding(VOCAB, 1, name="word_bias")
context_bias = layers.Embedding(VOCAB, 1, name="context_bias")
score = (ops.sum(word_vectors(word_id) * context_vectors(context_id),
                 axis=-1, keepdims=True)
         + word_bias(word_id) + context_bias(context_id))
glove = keras.Model([word_id, context_id], score)
glove.compile(optimizer=keras.optimizers.Adam(0.01), loss="mse")
glove.fit([ids_i[fit_ids], ids_j[fit_ids]], target_log_count[fit_ids],
          sample_weight=weights[fit_ids], batch_size=4096, epochs=12,
          validation_data=([ids_i[holdout_ids], ids_j[holdout_ids]],
                           target_log_count[holdout_ids], weights[holdout_ids]),
          callbacks=[keras.callbacks.EarlyStopping(
              monitor="val_loss", patience=2, restore_best_weights=True)], verbose=2)
print("Held-out observed-pair weighted MSE:", glove.evaluate(
    [ids_i[holdout_ids], ids_j[holdout_ids]], target_log_count[holdout_ids],
    sample_weight=weights[holdout_ids], verbose=0))

# GloVe commonly combines the two learned vector tables.
embeddings = (word_vectors.get_weights()[0] +
              context_vectors.get_weights()[0]).astype("float32")
embeddings[0] = 0  # padding stays inert downstream
word_index = imdb.get_word_index()
id_to_word = {index + 3: word for word, index in word_index.items()
              if index + 3 < VOCAB}
normalized = embeddings / np.maximum(np.linalg.norm(embeddings, axis=1,
                                                   keepdims=True), 1e-8)
for query in ("great", "bad", "movie"):
    token_id = word_index.get(query, -99) + 3
    if token_id not in id_to_word:
        continue
    similarity = normalized @ normalized[token_id]
    neighbors = [id_to_word[i] for i in np.argsort(-similarity)
                 if i in id_to_word and i != token_id][:5]
    print(f"Nearest to {query}: {neighbors}")

# Extrinsic evaluation: freeze GloVe and train a sentiment classifier.
classifier = keras.Sequential([
    keras.Input(shape=(LENGTH,), dtype="int32"),
    layers.Embedding(VOCAB, DIM, weights=[embeddings], trainable=False,
                     mask_zero=True, name="frozen_glove"),
    layers.GlobalAveragePooling1D(),
    layers.Dense(64, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(1, activation="sigmoid"),
])
classifier.compile(optimizer="adam", loss="binary_crossentropy",
                   metrics=[keras.metrics.BinaryAccuracy(name="accuracy"),
                            keras.metrics.AUC(name="auc")])
classifier.fit(X_train, y_train, validation_data=(X_val, y_val),
               batch_size=128, epochs=12, verbose=2,
               callbacks=[keras.callbacks.EarlyStopping(
                   monitor="val_loss", patience=2, restore_best_weights=True)])
print("Untouched sentiment test:", classifier.evaluate(X_test, y_test,
                                                         return_dict=True, verbose=0))
probabilities = classifier.predict(X_test, batch_size=256, verbose=0).ravel()
predictions = (probabilities >= 0.5).astype("int32")
print(classification_report(y_test, predictions,
                            target_names=["negative", "positive"],
                            zero_division=0))
cm = confusion_matrix(y_test, predictions, labels=[0, 1])
ConfusionMatrixDisplay(cm, display_labels=["negative", "positive"]).plot(
    cmap="Blues", colorbar=False)
plt.title("IMDb test · frozen GloVe vectors")
plt.tight_layout()
plt.savefig("glove_imdb_confusion.png", dpi=160)
plt.close()
glove.save("glove_cooccurrence.keras")
classifier.save("glove_imdb_classifier.keras")
print("Saved both .keras models and glove_imdb_confusion.png")
