| """ |
| GloVe embedding for fMRI language encoding. |
| |
| Uses the pre-trained GloVe 840B 300-d vectors. |
| Download from: |
| https://nlp.stanford.edu/data/glove.840B.300d.zip (~2.0 GB compressed) |
| |
| Place the decompressed text file at: |
| lab3/data/raw/glove.840B.300d.txt |
| |
| Alternatively the smaller 6B / 100-d set works too: |
| https://nlp.stanford.edu/data/glove.6B.zip → glove.6B.100d.txt (100-d) |
| |
| The pipeline mirrors bow.py and word2vec.py. |
| """ |
|
|
| import sys |
| import os |
| import numpy as np |
|
|
| sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) |
| from preprocessing import downsample_word_vectors, make_delayed |
|
|
| DEFAULT_GLOVE_PATH = os.path.join( |
| os.path.dirname(__file__), "../../data/raw/glove.840B.300d.txt" |
| ) |
| GLOVE_DIM = 300 |
|
|
|
|
| def load_glove(glove_path: str = DEFAULT_GLOVE_PATH) -> dict: |
| """Load GloVe vectors from a plain-text file into a dict {word: np.ndarray}.""" |
| print(f"Loading GloVe from {glove_path} …") |
| embeddings = {} |
| with open(glove_path, "r", encoding="utf-8") as f: |
| for line in f: |
| parts = line.rstrip().split(" ") |
| word = parts[0] |
| vec = np.array(parts[1:], dtype=np.float32) |
| embeddings[word] = vec |
| print(f"Loaded {len(embeddings):,} GloVe vectors (dim={next(iter(embeddings.values())).shape[0]})") |
| return embeddings |
|
|
|
|
| def get_glove_vectors(wordseqs: dict, glove: dict, dim: int = GLOVE_DIM) -> dict: |
| """Look up each word token in the GloVe dictionary. |
| |
| OOV words receive a zero vector. |
| |
| Returns: |
| {story: np.ndarray of shape (num_words, dim)} |
| """ |
| word_vectors = {} |
| oov_total = 0 |
| for story, ds in wordseqs.items(): |
| vecs = [] |
| for word in ds.data: |
| w = word.lower() |
| if w in glove: |
| vecs.append(glove[w]) |
| else: |
| vecs.append(np.zeros(dim, dtype=np.float32)) |
| oov_total += 1 |
| word_vectors[story] = np.array(vecs, dtype=np.float32) |
| if oov_total: |
| print(f"GloVe OOV tokens: {oov_total}") |
| return word_vectors |
|
|
|
|
| def process_glove(stories_train, stories_test, wordseqs, |
| glove_path=DEFAULT_GLOVE_PATH, dim=GLOVE_DIM, |
| trim_start=5, trim_end=10, delays=range(1, 5)): |
| """Full GloVe pipeline: embed → downsample → trim → lag.""" |
| glove = load_glove(glove_path) |
|
|
| all_stories = list(set(stories_train) | set(stories_test)) |
| word_vectors = get_glove_vectors( |
| {s: wordseqs[s] for s in all_stories}, glove, dim |
| ) |
|
|
| downsampled = downsample_word_vectors(all_stories, word_vectors, wordseqs) |
|
|
| def _trim_and_lag(stories): |
| mats = [] |
| for story in stories: |
| ds = downsampled[story] |
| trimmed = ds[trim_start: len(ds) - trim_end] |
| lagged = make_delayed(trimmed, list(delays)) |
| mats.append(lagged) |
| return np.vstack(mats) |
|
|
| X_train = _trim_and_lag(stories_train) |
| X_test = _trim_and_lag(stories_test) |
| return X_train, X_test |
|
|
|
|
| if __name__ == "__main__": |
| import pickle |
| wordseqs = pickle.load(open(sys.argv[1], "rb")) |
| train_list = sys.argv[2].split(",") |
| test_list = sys.argv[3].split(",") |
| out_prefix = sys.argv[4] |
| glove_path = sys.argv[5] if len(sys.argv) > 5 else DEFAULT_GLOVE_PATH |
|
|
| X_train, X_test = process_glove(train_list, test_list, wordseqs, glove_path) |
| np.save(f"{out_prefix}_train_glove_embeddings.npy", X_train) |
| np.save(f"{out_prefix}_test_glove_embeddings.npy", X_test) |
| print(f"Saved GloVe embeddings: train {X_train.shape}, test {X_test.shape}") |
|
|
