Embeddings TF

import tensorflow as tf
from tensorflow import keras
import numpy as np

keras.utils.set_random_seed(2026)

_course_titles = tf.constant([
    "Regional leaders agree on a public health plan",
    "The home team wins the basketball final",
    "Markets rise after a strong business report",
    "Researchers release an efficient intelligence model",
    "Diplomats begin a new round of peace talks",
    "The tennis champion returns after an injury",
    "Retail sales improve with consumer confidence",
    "A software update improves privacy",
    "Observers publish guidance for a national election",
    "A football club signs a young goalkeeper",
    "A local company creates new apprenticeships",
    "Engineers test a compact satellite sensor",
    "Countries publish a shared emergency schedule",
    "Swimmers prepare for the regional games",
    "The central bank reviews recent economic data",
    "Scientists document a lower-energy battery process",
])
_course_descriptions = tf.constant([
    "World policy and international cooperation",
    "Sports results and player development",
    "Business revenue and economic indicators",
    "Science and technology research",
    "World diplomacy and humanitarian aid",
    "Sports training and competition",
    "Business investment and employment",
    "Science security and technology",
    "World elections and public institutions",
    "Sports teams and competition",
    "Business jobs and local investment",
    "Science engineering and space technology",
    "World cooperation and emergency planning",
    "Sports preparation and inclusive events",
    "Business banking and economic policy",
    "Science energy and materials research",
])
_course_labels = tf.constant(
    [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3],
    dtype=tf.int64,
)
_course_records = {
    "title": _course_titles,
    "description": _course_descriptions,
    "label": _course_labels,
}
ds_train = tf.data.Dataset.from_tensor_slices(_course_records).take(12)
ds_test = tf.data.Dataset.from_tensor_slices(_course_records).skip(12)

vocab_size = 30000
batch_size = 128

vectorizer = keras.layers.TextVectorization(max_tokens=vocab_size, output_mode="int")

model = keras.models.Sequential([
    keras.Input(shape=(), dtype=tf.string),
    vectorizer,
    keras.layers.Embedding(vocab_size, 100, mask_zero=True),
    keras.layers.GlobalAveragePooling1D(),
    keras.layers.Dense(4, activation="softmax"),
])
model.summary()

def extract_text(x):
    return x['title']+' '+x['description']

def tupelize(x):
    return (extract_text(x),x['label'])

print("Training vectorizer")
vectorizer.adapt(ds_train.take(500).map(extract_text))

model.compile(loss='sparse_categorical_crossentropy',metrics=['acc'])
model.fit(ds_train.map(tupelize).batch(batch_size),validation_data=ds_test.map(tupelize).batch(batch_size))

print(vectorizer('Hello, world!'))
print(vectorizer('I am glad to meet you!'))

vectorizer(['Hello, world!','I am glad to meet you!'])

model.layers[1](vectorizer(['Hello, world!','I am glad to meet you!'])).numpy()

# course-edition deterministic TensorFlow semantic vectors v1
COURSE_SEMANTIC_GROUPS = [
    ("royalty", {"king", "queen"}),
    ("masculine", {"king", "man"}),
    ("feminine", {"queen", "woman"}),
    ("sports", {"athletes", "basketball", "coach", "football", "play", "runner", "swimming", "team", "tennis", "volleyball"}),
    ("business", {"bank", "business", "companies", "contracts", "funds", "market", "payment", "prices", "revenue", "sales"}),
    ("technology", {"battery", "cloud", "engineers", "model", "neural", "researchers", "robot", "satellite", "scientists", "sensor", "software", "technology"}),
    ("world", {"council", "countries", "diplomats", "election", "ministers", "paris", "regional", "summit"}),
    ("care", {"emergency", "health", "hospital", "humanitarian", "medicine", "relief", "safety"}),
]
COURSE_SEMANTIC_TOKENS = sorted({
    token
    for _name, members in COURSE_SEMANTIC_GROUPS
    for token in members
})

def course_semantic_vector(word):
    """Return the eight visible concept coordinates for one token."""
    return [
        1.0 if word in members else 0.0
        for _name, members in COURSE_SEMANTIC_GROUPS
    ]

def course_cosine_similarity(left, right):
    numerator = sum(a * b for a, b in zip(left, right))
    left_norm = sum(value * value for value in left) ** 0.5
    right_norm = sum(value * value for value in right) ** 0.5
    if left_norm == 0.0 or right_norm == 0.0:
        return -1.0
    return numerator / (left_norm * right_norm)

class CourseSemanticVectors:
    """Small edition-authored vectors with a familiar lookup interface."""

    def __init__(self):
        self.tokens = list(COURSE_SEMANTIC_TOKENS)
        self.vectors = {
            token: course_semantic_vector(token)
            for token in self.tokens
        }

    def get_vector(self, word):
        if word not in self.vectors:
            raise ValueError(f"No authored semantic vector for {word!r}")
        return list(self.vectors[word])

    def nearest_to_vector(self, query, exclude=(), topn=5):
        excluded = set(exclude)
        ranked = [
            (token, course_cosine_similarity(query, vector))
            for token, vector in self.vectors.items()
            if token not in excluded
        ]
        ranked.sort(key=lambda item: (-item[1], item[0]))
        return ranked[:topn]

    def most_similar(self, word=None, positive=None, negative=None, topn=5):
        positive_words = list(positive or ([] if word is None else [word]))
        negative_words = list(negative or [])
        if not positive_words and not negative_words:
            raise ValueError("Provide a word or at least one positive/negative token")
        query = [0.0] * len(COURSE_SEMANTIC_GROUPS)
        for token in positive_words:
            query = [
                current + value
                for current, value in zip(query, self.get_vector(token))
            ]
        for token in negative_words:
            query = [
                current - value
                for current, value in zip(query, self.get_vector(token))
            ]
        return self.nearest_to_vector(
            query,
            exclude={*positive_words, *negative_words},
            topn=topn,
        )

course_semantics = CourseSemanticVectors()

for word, score in course_semantics.most_similar("neural"):
    print(f"{word} -> {score:.3f}")

course_semantics.get_vector("play")

course_semantics.most_similar(
    positive=["king", "woman"],
    negative=["man"],
    topn=1,
)[0]

qvec = [
    king - man + woman
    for king, man, woman in zip(
        course_semantics.get_vector("king"),
        course_semantics.get_vector("man"),
        course_semantics.get_vector("woman"),
    )
]
course_semantics.nearest_to_vector(
    qvec,
    exclude={"king", "man", "woman"},
    topn=1,
)[0]

vocab = vectorizer.get_vocabulary()
W = np.asarray(
    [course_semantic_vector(word) for word in vocab],
    dtype="float32",
)
vocab_size = len(vocab)
embed_size = W.shape[1]
covered = sum(any(row) for row in W)
print(f"Embedding size: {embed_size}; authored coverage: {covered}/{vocab_size}")

emb = keras.layers.Embedding(
    input_dim=vocab_size,
    output_dim=embed_size,
    weights=[W],
    trainable=False,
    mask_zero=True,
)
model = keras.models.Sequential([
    keras.Input(shape=(), dtype=tf.string),
    vectorizer,
    emb,
    keras.layers.GlobalAveragePooling1D(),
    keras.layers.Dense(4, activation="softmax"),
])

model.compile(loss="sparse_categorical_crossentropy", metrics=["acc"])
model.fit(
    ds_train.map(tupelize).batch(batch_size),
    validation_data=ds_test.map(tupelize).batch(batch_size),
    epochs=2,
)

semantic_vectorizer = keras.layers.TextVectorization(output_mode="int")
semantic_vectorizer.set_vocabulary(COURSE_SEMANTIC_TOKENS)
semantic_vocabulary = semantic_vectorizer.get_vocabulary()
semantic_W = np.asarray(
    [course_semantic_vector(word) for word in semantic_vocabulary],
    dtype="float32",
)

semantic_embedding = keras.layers.Embedding(
    input_dim=len(semantic_vocabulary),
    output_dim=semantic_W.shape[1],
    weights=[semantic_W],
    trainable=False,
    mask_zero=True,
)
semantic_model = keras.models.Sequential([
    keras.Input(shape=(), dtype=tf.string),
    semantic_vectorizer,
    semantic_embedding,
    keras.layers.GlobalAveragePooling1D(),
    keras.layers.Dense(4, activation="softmax"),
])
semantic_model.compile(
    loss="sparse_categorical_crossentropy",
    metrics=["acc"],
)
semantic_model.fit(
    ds_train.map(tupelize).batch(batch_size),
    validation_data=ds_test.map(tupelize).batch(batch_size),
    epochs=2,
)