Embeddings and Representation Learning

References

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

1. Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares

   Boyd and Vandenberghe define the dot product as the sum of coordinatewise products, the L2 norm as the square root of a vector’s self-inner-product, and Euclidean distance as ||u-v||. For nonzero vectors, the normalized dot product is cos(theta), so cosine comparison removes positive overall scale. For unit vectors, expanding the squared distance gives ||u-v||²=2-2uᵀv; therefore maximizing cosine or dot product and minimizing Euclidean distance produce the same ranking. A matrix with orthonormal columns preserves norms, inner products, and angles; applying it to both vectors consequently preserves their Euclidean distance as well.

2. Understanding Intermediate Layers Using Linear Classifier Probes

   A linear probe trains a classifier on a layer's representations while preventing its gradients from changing the underlying model. The paper distinguishes information retained in a representation from how readily a restricted predictor can use it: successive transformations can improve linear separability without adding information about the input. It defines separate training, validation, and test measurements and discusses probe overfitting. Held-out probe success therefore supports accessibility to that predictor; failure of a linear probe alone does not establish absence of information accessible through other functions.

3. Deep Learning, Chapter 15: Representation Learning

   A useful representation makes a subsequent learning task easier; its usefulness depends on that task. In supervised networks, intermediate layers learn features that support the final predictor, and changing that predictor can change which properties are useful. Representation learning can trade preservation of input information against desired properties of the representation. A distributed representation describes an input through combinations of multiple feature values rather than assigning a separate feature to every possible concept.

4. Deep Learning, Chapter 14: Autoencoders

   An autoencoder combines an encoder h=f(x) with a decoder reconstructing x from h. Training penalizes reconstruction error. Restricting code size or imposing regularization makes the model prioritize information instead of merely copying inputs. With a linear decoder and squared-error loss, an undercomplete autoencoder learns the principal subspace associated with PCA. Overcomplete representations can have more coordinates than their inputs; regularization rather than dimensional reduction can constrain them. Even a small bottleneck does not ensure useful features when encoder and decoder capacity permit memorizing training examples.

5. Embeddings are Stunting Agents: How Codeium Breaks Through the Ceiling for Retrieval

   Codeium hypothesizes that fixed-dimensional embeddings cannot preserve all distinctions needed to answer arbitrary queries, and that semantic distance may not capture task-specific function relevance.

6. Dimensionality Reduction by Learning an Invariant Mapping

   DrLIM learns a function that maps new inputs into a space using supplied neighbor relationships, rather than requiring raw-input distance to express the desired similarity. Contrastive training pulls designated neighbors together and separates non-neighbors. In its airplane-image experiment, neighboring camera views are paired regardless of lighting; the authors report an output organized by viewing direction while insensitive to the tested lighting changes. Pair construction therefore determines which variation the representation should preserve or ignore.

7. This Is Not Correct! Negation-aware Evaluation of Language Generation Systems

   The authors fine-tune all-mpnet-base-v2 on negated and paraphrased sentence pairs and compare cosine-based evaluation before and after adaptation. Their perturbation experiments show improved sensitivity to negation and antonyms, while the tested sentence encoders remain insensitive to many other edits, including number replacement. The broader embedding comparison reports gains for some task categories and decreases for others. Improving one decisive distinction therefore does not establish general semantic fidelity or unchanged task fit.

8. Gemini API Embeddings documentation

   Google explicitly documents that the spaces produced by gemini-embedding-001 and gemini-embedding-2 are incompatible: vectors from the two models cannot be compared directly, and migration requires re-embedding existing data. The versions also differ in task instructions, multi-input aggregation and normalization behavior. This is a concrete operational case where equal supported output dimensions do not establish compatibility; model version, task formatting, aggregation, dimensionality and normalization are parts of the comparison contract.

9. PyTorch Embedding

   PyTorch's Embedding stores a learnable matrix with shape (num_embeddings, embedding_dim). Integer inputs select rows; the output appends the vector dimension to the input shape. The published example uses ten three-coordinate vectors and shows repeated indices returning the same row. Thus dictionary size and vector dimensionality are different quantities. The sparse option concerns gradients of the weight matrix, not a promise that returned embedding vectors contain mostly zeros.

10. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding

    Devlin, Chang, Lee and Toutanova posted BERT in 2018 and published it at NAACL 2019. Its masked-language-model objective predicts selected original token IDs from both left and right context, avoiding the information leak that ordinary bidirectional next-token prediction would create. BERT distinguishes input token, segment and position embeddings from final contextual token states; for classification, the final state of a prepended CLS token serves as an aggregate sequence representation. The same pretrained parameters initialize multiple downstream models, which are then fine-tuned separately.

11. How LLMs work for Web Devs: GPT in 600 lines of Vanilla JS

    A token ID identifies a vocabulary entry; its embedding supplies the numeric representation used to express relationships and perform model computation.

12. Sentence-BERT: Sentence Embeddings Using Siamese BERT-Networks

    SBERT combines contextual token outputs into a fixed-size sentence vector using pooling; tested options include the CLS output, coordinate-wise maxima, and mean pooling. It trains these representations with classification, cosine-regression, or triplet objectives. Its triplet loss is max(d(a,p)-d(a,n)+margin,0): an anchor's positive should be closer than its negative by the margin. On the paper's semantic textual similarity evaluations, directly averaging unadapted BERT outputs or taking CLS performs worse than averaged GloVe; task-oriented fine-tuning improves the comparisons. Pooling alone therefore does not establish useful sentence-similarity geometry.

13. Sentence Transformers: SentenceTransformer API

    The API allows selecting a model revision, including a commit identifier, and separately configuring prompts, returned representation type, normalization, output precision, and truncated output dimension. Its encode method can return sentence vectors or token representations. Input-length truncation is a separate preprocessing setting from output-vector truncation. Query and document methods can select role conventions, but return the same embeddings when a model has no corresponding prompts or task distinctions.

14. How Contextual Are Contextualized Word Representations? Comparing the Geometry of BERT, ELMo, and GPT-2 Embeddings

    Contextual representations vary with the surrounding input, unlike a fixed word lookup vector. The paper compares occurrences of the same word across contexts and distinguishes input embeddings from later contextual states. It defines isotropy as directional uniformity and finds strong directional concentration in the tested contextual layers. Consequently, a high cosine score must be interpreted against the space's background geometry. Its diagnostics include average cosine between randomly sampled word occurrences and the variance explained by a principal component.

15. Google Recommendation Systems: Matrix factorization

    Matrix factorization learns compact user and item embeddings whose dot products approximate observed feedback. The interaction matrix is sparse: missing entries do not directly say that a user dislikes an item. Fitting only positive observations can produce a trivial predictor, while treating all missing entries equally as negatives can let them dominate. Weighted objectives balance observed and unobserved interactions and can adjust for highly frequent users or items. Representation learning and the meaning assigned to feedback are therefore inseparable.

16. Learning Transferable Visual Models From Natural Language Supervision

    CLIP trains separate image and text encoders so matching image-caption pairs have higher similarity than mismatched pairs. At inference, descriptions of candidate labels can be embedded and compared with an image, enabling classification without training a new label-specific head. The learned similarity space also supports retrieval. This is alignment from paired data, not a symbolic database of visual facts; candidate descriptions and data coverage affect what comparisons mean. Zero-shot transfer evaluates a different adaptation regime from training on the target dataset.

17. E5-base-v2 Model Card

    E5-base-v2 documents a concrete embedding contract: English input, 768-dimensional output, a maximum of 512 tokens, average pooling over unmasked token states, and L2 normalization in its example. Its authors require query and passage prefixes for the respective retrieval roles and recommend query prefixes for symmetric or feature-based tasks. They report cosine scores commonly around 0.7–1.0 and attribute this to low-temperature contrastive training. Thus a high absolute score or matching vector shape is insufficient to interpret a comparison independently of the model and its input conventions.

18. Distributional Structure

    Harris defines an element's distribution through the environments in which it occurs. His 1954 paper argues that differences in these environments provide evidence about differences in meaning. The example contrasts oculist and eye-doctor, which occur in nearly identical environments, with lawyer, whose usage overlaps less. He explicitly distinguishes occurrence patterns from whether a particular statement is true and acknowledges that observed environments cannot fully define a word's meaning.

19. A Vector Space Model for Automatic Indexing

    Salton, Wong and Yang represent documents as vectors whose coordinates are index-term weights. Their three-dimensional illustration extends to one coordinate per indexing term, with angular similarity comparing documents. The representation changes when terms or weights change. Their motivating question is which representation makes useful documents distinguishable for retrieval; they acknowledge that future users' relevance judgments cannot simply be known during indexing.

20. Indexing by Latent Semantic Analysis

    Deerwester and colleagues motivate latent semantic indexing with vocabulary mismatch: relevant documents may use different words, while identical words may have different meanings. Their method applies singular-value decomposition to a term–document matrix and retains fewer factors, representing terms and documents through those shared dimensions. These latent factors summarize patterns of association rather than requiring individually interpreted axes. A term can consequently lie near a document that does not contain it because of broader associations in the collection.

21. Signature Verification using a "Siamese" Time Delay Neural Network

    Bromley, Guyon, LeCun, Säckinger and Shah presented a Siamese neural network at NeurIPS 1993 for dynamic signature verification. Two weight-sharing subnetworks converted signature trajectories into feature vectors; training rewarded a small angle for genuine pairs and a large angle for pairs containing a forgery. Verification compared an encoded signature with a stored signer representation using a threshold. The design was motivated partly by an 80-byte storage constraint, making learned pairwise compatibility a practical alternative to storing complete trajectories.

22. A Neural Probabilistic Language Model

    Bengio and colleagues jointly learn a word-vector table and a function predicting the next word from preceding word vectors. Each vocabulary item selects a row of a shared parameter matrix. Their motivation is generalization to word sequences absent from training: related word representations let observations inform predictions beyond exact previously observed sequences. This offers a different mechanism from relying on counts of short word sequences, while retaining word prediction as the training task.

23. Efficient Estimation of Word Representations in Vector Space

    Continuous bag-of-words predicts a target word from surrounding word representations, combining context without preserving its order. Skip-gram reverses that prediction direction: the current word predicts words within a surrounding window. Thus observed linguistic contexts provide training targets for word vectors without requiring manually assigned semantic coordinates. The paper evaluates learned relationships separately rather than treating successful context prediction as sufficient evidence of every useful word relation.

24. Neural Word Embedding as Implicit Matrix Factorization

    Levy and Goldberg analyze skip-gram with negative sampling as an implicit factorization of word–context association statistics. Under their formulation, unconstrained optimal pair scores equal pointwise mutual information minus a constant determined by negative sampling. Pointwise mutual information compares observed co-occurrence with what independent occurrence would predict. With restricted vector dimensions, the objective becomes a weighted approximation that emphasizes frequent pairs. Prediction and matrix factorization therefore need not represent unrelated approaches.

25. Deep Contextualized Word Representations

    Peters and colleagues introduced ELMo at NAACL 2018 to replace one context-independent vector per word type with occurrence-specific representations derived from a bidirectional language model. Each token's vector is a task-specific weighted combination of the character-based input layer and internal forward and backward LSTM states, so identical spellings can receive different states in different sentences. The pretrained language-model weights remain fixed while downstream models learn how to combine the layers. Adding ELMo improved all six evaluated language-understanding systems.

26. Is Cosine-Similarity of Embeddings Really About Similarity?

    For the paper's linear factorization models, some objectives admit different embedding factorizations with unchanged predictions but different cosine similarities. A shared rotation preserves cosine, while reciprocal rescaling of latent dimensions in the two factors can preserve their product yet change normalized comparisons. Other regularization choices restrict this freedom differently. The result supplies a concrete reason why prediction quality does not automatically validate cosine geometry and why normalization is a modeling choice rather than a universally harmless cleanup.

27. scikit-learn: Nearest Neighbors

    A k-nearest-neighbor query selects a fixed number of closest samples under a chosen distance, while a radius query selects samples inside a distance boundary and can return different counts in differently populated regions. The documentation provides a small six-point coordinate fixture with neighbor indices and distances. It warns that tied distances at the selection boundary can make results depend on input ordering. A nearest-neighbor result is therefore relative to the supplied collection, distance, requested neighborhood size, and tie handling.

28. Retrieval Augmented Generation in the Wild

    Nearest-neighbor retrieval returns candidates even when the corpus cannot answer the query; rank alone does not establish relevance.

29. Hubs in Space: Popular Nearest Neighbors in High-Dimensional Data

    Hubness concerns the distribution of k-occurrence counts: how often each point appears in other points' k-nearest-neighbor sets. Hubs have unusually large counts. Distance concentration instead concerns distance spread becoming small relative to distance magnitude under increasing dimension and specified distributions. The paper studies their relationship through synthetic and real datasets. Its experiments include a counterexample to automatic hubness: cosine distance with normally distributed data does not show the same skew seen for several other settings. Neighbor occurrence counts and relative distance spread consequently measure different phenomena.

30. How to Use t-SNE Effectively

    The authors' controlled examples show that t-SNE layouts change with perplexity, optimization progress, and sometimes random runs. Its density adaptation can make clusters with different original spreads look similarly sized. Distances between displayed clusters can misrepresent their original relationships, and low-perplexity views can create apparent clumps from random data. Multiple displays can reveal instability that a single attractive plot hides.

31. UMAP: Using UMAP for Clustering

    UMAP's documentation warns that its projection does not completely preserve density and can introduce false tears, making a group appear split more finely than in the original data. It explains that smaller neighborhood settings emphasize local structure and can expose noise as apparent clusters, while min_dist changes how tightly points are packed. Its worked example evaluates clustering against labels rather than using the visualization alone as evidence.

32. On Linear Identifiability of Learned Representations

    Roeder, Metz and Kingma study when discriminatively trained representations are identifiable in function space even though neural-network parameters are overparameterized. Under their sufficient conditions, independently optimal representation functions are determined only up to an invertible linear transformation. Thus a task can constrain represented information without assigning a unique coordinate system: corresponding representations may require an estimated linear map before coordinatewise comparison.

33. Masked Autoencoders Are Scalable Vision Learners

    MAE randomly removes image patches, commonly 75% in the paper, and sends only visible patch embeddings with positions through the encoder. A smaller decoder receives encoded visible patches plus mask tokens and positional information for all locations. It predicts patch pixels and minimizes mean squared reconstruction error only on masked patches; a variant normalizes target pixels within each patch. The decoder is discarded for downstream recognition. Unlike supervised classification, targets come from hidden portions of the input rather than category annotations. Unlike paired image-text contrastive learning, the objective reconstructs image content rather than distinguishing matched from mismatched image-caption pairs.

34. Improving Distributional Similarity with Lessons Learned from Word Embeddings

    The authors transfer choices such as context-distribution smoothing and context-window configuration between predictive and count-based word representations. Their comparisons find no consistently superior approach across the tested word-similarity and analogy tasks after tuning these choices. Some advantages previously attributed to a model family instead depend on preprocessing, hyperparameters, or evaluation conditions. The work supports explaining count-based and predictive methods as connected alternatives rather than an inevitable replacement sequence.

35. A Simple Framework for Contrastive Learning of Visual Representations

    SimCLR makes two augmented views of an image a positive pair and uses the other images' views in the batch as negatives. An encoder produces features; a projection head produces vectors for the loss. For anchor i and positive j, the loss is -log(exp(s_ij/tau)/sum_{k≠i}exp(s_ik/tau)), with cosine scores and positive temperature tau. Lower temperature sharpens relative weights. Identical nonzero vectors give equal scores and loss log(2N-1), so they cannot preferentially identify the positive. This is a discrimination objective, not calibrated real-world relevance. The authors discard the projection head for downstream use and show that augmentation choices affect representation quality even when the contrastive task is solved well.

36. Representation Learning with Contrastive Predictive Coding

    Contrastive Predictive Coding encodes observations and summarizes preceding representations to distinguish a future observation from sampled alternatives. Its InfoNCE loss is negative log probability of selecting the positive, calculated by dividing its positive-valued score by the sum of candidate scores. This replaces direct prediction of high-dimensional observations with discrimination in representation space. The probability concerns which sample came from the specified conditional distribution, rather than the truth or relevance of arbitrary content.

37. Sentence Transformers: Losses

    MultipleNegativesRankingLoss supports positive pairs such as paraphrases, duplicate questions, query-response pairs, and translations. Its default objective makes an anchor's matched positive score above other documents in the batch, optionally including explicit negatives. Similarity scores are multiplied by a scale equal to inverse temperature. The documentation recommends batches without duplicate anchor or positive texts. Its MegaBatchMarginLoss defines a hard negative operationally as another pair's positive with maximal cosine similarity to the anchor. Forward query-to-document discrimination and reverse document-to-query discrimination are separately selectable.

38. Debiased Contrastive Learning

    Sampling contrastive negatives from the overall data distribution can select an example that is genuinely similar to the anchor. The paper calls this sampling bias and illustrates false negatives with same-class examples. Its controlled CIFAR-10 comparison finds better representations when negatives come from different labels rather than unrestricted sampling. The proposed correction approximates a negative distribution without requiring each example's true label.

39. Foundations of Computer Vision: Training for Robustness and Generality

    Label-preserving augmentation assumes y(T(x))=y(x). This is task-dependent: mirroring can preserve a scene category while changing a character's identity. When targets have spatial structure, transform image and target together so y(Tx)=T_y(y(x)); a segmentation crop must crop the label map at the same coordinates. Augmentation teaches selected invariances or equivariances by adding transformed training examples. It cannot repair an invalid label-preservation assumption or supply an independent evaluation sample.

40. Foundations of Computer Vision: Convolutional Neural Nets

    Translation equivariance means translating an input translates its feature map: f(Tx)=T f(x). Invariance means the output stays unchanged: f(Tx)=f(x). Shared convolution supports equivariance; pooling can suppress sensitivity to feature position within its pooling region. Global pooling removes spatial position more extensively. Downsampling reduces spatial resolution while deeper layers combine larger neighborhoods and often encode more category-related features. This exchanges detailed localization for contextual coverage rather than creating new image evidence.

41. VICReg: Variance-Invariance-Covariance Regularization for Self-Supervised Learning

    Making paired representations agree admits a trivial solution if all inputs map to the same vector. VICReg separates an invariance term for matching views, a variance term encouraging nonzero variation across examples in each coordinate, and a covariance term discouraging redundant coordinates. This distinguishes constant-output collapse from representations that vary but repeat information across dimensions. The method demonstrates that useful representation learning need not always use explicit negative pairs.

42. How Transformers Finally Ate Vision

    Frozen pretrained features can be evaluated with a learned linear projection, isolating how much useful information the representation already contains.

43. Adversarial Removal of Demographic Attributes from Text Data

    The study trains text encoders for sentiment or mention prediction, then trains separate classifiers to recover demographic labels from their representations. The attacker receives encoded examples rather than original text or encoder access. Demographic information remains recoverable in the studied settings, including after adversarial training makes the original adversary perform near chance. This demonstrates that an intended task and an unintended attribute predictor can both use the same representation, and that one unsuccessful attacker does not establish information removal.

44. The Hidden Life of Embeddings

    The demonstrated custom T5 denoising autoencoder encodes text into a pooled embedding and decodes that embedding back into approximately reconstructed text.

45. The Hidden Life of Embeddings

    A trained linear adapter let the custom decoder recover approximate text, including some proper nouns and structure, from an OpenAI embedding without source text at decoding time.

46. Text Embeddings Reveal (Almost) As Much As Text

    Text embeddings represent text numerically for uses including retrieval, but that transformation need not conceal the source. The authors train Vec2Text to reconstruct inputs from embeddings and demonstrate recovery of names from clinical-note embeddings. Their threat model includes access to embeddings and text–embedding pairs from the relevant encoder. The experiments provide a concrete reason to include retrieval representations in sensitive-data inventories rather than treating them as automatically anonymous.

47. MTEB: Massive Text Embedding Benchmark

    MTEB evaluates distinct uses of embeddings: training a classifier on frozen vectors, clustering, classifying labeled text pairs using scores and thresholds, and retrieving relevant documents, among others. Its original comparison finds substantial task dependence: models strong on semantic textual similarity can perform poorly on retrieval and vice versa. Multilingual results also vary by task and language. These findings support evaluating the intended readout and population rather than transferring a model's reputation from one benchmark category.

48. BEIR: A Heterogeneous Benchmark for Zero-shot Evaluation of Information Retrieval Models

    BEIR evaluates retrieval across different tasks and domains rather than assuming performance transfers from one training collection. The studied dense retrievers perform strongly on some datasets but fall below the lexical BM25 baseline on others, including substantial domain or task shifts. The authors also observe markedly different retrieved-document lengths for TAS-B and ANCE. These results make domain coverage, task relationship and document length concrete dimensions of representation evaluation.

49. SimLex-999: Evaluating Semantic Models With (Genuine) Similarity Estimation

    SimLex distinguishes similarity from association: cup and mug share properties, whereas coffee and cup are associated without being interchangeable. Its annotations explicitly target similarity, including strongly associated pairs that should receive low similarity ratings. The evaluated distributional models capture association more readily than this narrower similarity relation. Choosing an evaluation dataset therefore also chooses which semantic relationship the representation is being rewarded for exposing.

50. Benchmarking semantic code retrieval on Claude Code

    In the speaker's fifty-task evaluation, windowing plus semantic search improved precision, but default Claude Code retained the best file recall and the two windowed conditions had roughly similar recall.

51. The RAG Stack We Landed On After 37 Fails

    In the illustrated station-help query, changing the embedding model and generator changed the answer but did not produce an answer the speaker considered helpful.

52. How to look at your data; what to look for, how to measure

    A better application evaluation score is a reason to consider switching, but re-embedding work and service characteristics remain part of the decision.

53. How to look at your data; what to look for, how to measure

    Check both score proximity and preservation of model ordering between synthetic queries and logged user queries.

54. How to look at your data; what to look for, how to measure

    The reported Weights & Biases chatbot evaluation favored voyage-3-large, while the original text-embedding-3-small performed worst among the tested models and jina-embeddings-v3 did not perform as well as its public benchmark standing suggested.

55. Benchmarking semantic code retrieval on Claude Code

    The experiment introduced a maximum of fifty lines per read because whole-file reads made retrieval differences difficult to distinguish.

56. Dense Passage Retrieval for Open-Domain Question Answering

    DPR uses separate encoders for questions and passages, then scores a pair by the dot product of its vectors. Passage vectors can be computed and indexed offline; a new question is encoded at request time and used to retrieve high-scoring passages. Training contrasts relevant passages with negatives so similarity becomes useful for the retrieval task. This factorization explains efficient candidate retrieval and its limitation: a similarity score is a learned ranking signal, not a probability that a passage proves the answer. Lexical retrieval such as BM25 instead exploits matching terms and remains a useful comparator.

57. Dense Passage Retrieval for Open-Domain Question Answering

    DPR uses separate encoders for questions and passages, then scores a pair by the dot product of its vectors. Passage vectors can be computed and indexed offline; a new question is encoded at request time and used to retrieve high-scoring passages. Training contrasts relevant passages with negatives so similarity becomes useful for the retrieval task. This factorization explains efficient candidate retrieval and its limitation: a similarity score is a learned ranking signal, not a probability that a passage proves the answer. Lexical retrieval such as BM25 instead exploits matching terms and remains a useful comparator.

58. Sentence Transformers: semantic search

    Semantic retrieval encodes corpus documents and queries into compatible vectors, then ranks corpus entries by similarity. For asymmetric retrieval, the documentation recommends encode_document for corpus entries and encode_query for queries. Cosine similarity compares vector direction; with unit-normalized vectors it equals their dot product. Corpus vectors can be computed ahead of queries and indexed with associated document data, while each incoming query gets its own vector. These retrieval outputs represent searchable text units; they are not the generator's sequence of internal token states. That distinction follows by comparing this interface with the transformer's token-level architecture.

59. What We Learned from Using LLMs in Pinterest

    The production student uses a bi-encoder, also discussed as a two-tower architecture, with offline pin embeddings and cached online query embeddings.

60. The RAG Stack We Landed On After 37 Fails

    Use a bi-encoder for broad candidate retrieval and a cross-encoder, also called a re-ranker, for a smaller post-retrieval candidate set.

61. Content-based Filtering

    Content-based recommendation represents item properties and user preferences in a shared feature space and scores candidate items by similarity, such as a dot product. It can reason about an item through its attributes rather than requiring that item to already have a dense interaction history. This distinguishes metadata-based matching from collaborative factorization. The representation still determines which interests can be expressed, and a new user still needs preference evidence or an explicitly chosen initial policy.

62. One model to rule recommendations: Netflix's Big Bet

    Complement learned item-ID embeddings with semantic content embeddings to address cold start.

63. Knowledge Graphs & GraphRAG: Techniques for Building Effective GenAI Applications: Zach Blumenthal

    Graph embeddings can represent structural or positional similarity, supplying a different recommendation signal from text embeddings.

64. Recsys Keynote: Improving Recommendation Systems & Search in the Age of LLMs

    The Etsy example combines text and query–product interaction information with user preference features in a two-tower retrieval system.

65. Two-tower retrieval, approximation and compatible deployment artifacts

    Separate user/query and item models produce embeddings in a shared scoring space. Item vectors can be computed before requests and indexed with item identifiers; serving computes the query vector and retrieves high-scoring candidates. Brute force evaluates the catalog, while ScaNN searches approximately and may miss exact top-K items. Search breadth and rescoring settings trade latency against retrieval accuracy; compare approximate results with brute force on the same candidates. The tutorial exports a SavedModel containing the query model and index. Engineering inference: deployment must keep query weights/preprocessing compatible with candidate vectors, identifiers, scoring conventions and index. Changing the item encoder requires recomputing affected vectors and updating or rebuilding the index; changing both towers requires a matching index. Retain a compatible bundle for rollback.

66. 120k players in a week: Lessons from the first viral CLIP app: Joseph Nelson

    Paint.wtf uses CLIP (Contrastive Language-Image Pre-Training) to rank drawings by cosine similarity between prompt and image embeddings.

67. Zero-Shot Content Moderation with OpenAI's New CLIP Model

    Paint.wtf's developers describe ranking submitted drawings by cosine similarity between CLIP image embeddings and prompt embeddings. They report that players could obtain favorable scores by writing the prompt's words in the image instead of drawing its subject. The developers added a penalty based on similarity to a written-letters description. This is a concrete case where a model's learned correspondence differs from the application's intended notion of a good match.

68. When and Why Vision-Language Models Behave like Bags-of-Words, and What to Do About It?

    ARO tests whether image–text models distinguish reversed relations, reassigned attributes and reordered captions. Its tests retain constituent words while changing their relationship, separating recognition of objects from recognition of who does what or which property belongs to which object. Experiments with CLIP and other models reveal deficiencies on these distinctions. Separate perturbation experiments show that strong retrieval results can survive substantial disruption of caption order, so retrieval success alone does not establish compositional understanding.

69. Building Multimodal AI Agents (From Scratch)

    The agent must resolve retrieved image references and provide the actual images to a multimodal LLM; an embedding model alone does not interpret the retrieved pages for the user.

70. Word Embedding-based Antonym Detection Using Thesauri and Distributional Information

    Antonyms such as strong and weak can occur in similar contexts, so distributional word embeddings often fail to distinguish opposition from similarity. The authors add explicit synonym and antonym supervision from thesauri, rewarding high scores for synonyms and low scores for antonyms, alongside distributional information. This supplies a concrete example of changing training relationships to preserve a distinction that context prediction alone does not reliably expose.

71. The PASCAL Recognising Textual Entailment Challenge

    The challenge defines textual entailment as a directional relationship: a hypothesis follows from a supplied text under ordinary language interpretation and background knowledge. Its examples distinguish supported conclusions from statements that merely concern the same entities. It treats semantic equivalence as requiring entailment in both directions. This gives an operational meaning to implication that differs from undirected resemblance.

72. Graph Intelligence: Enhance Reasoning and Retrieval Using Graph Analytics

    GraphRAG can use vector search to find an entity and then traverse existing relationships to retrieve contextual entities.

73. Stop Using RAG as Memory

    Semantic similarity alone does not distinguish task-relevant facts from facts with misleading associations.

74. PROV-DM: The PROV Data Model

    PROV represents artifacts as entities, transformations as activities, and responsible people, organizations or software as agents. Usage links an activity to an input entity; generation links an output entity to its producing activity; derivation connects output to source. Attribution associates an entity with an agent, while association assigns responsibility for an activity. Revision is a specialized derivation. Application mapping: identify each source revision, extracted representation and chunk separately; record the extraction or chunking activity, its inputs, outputs and responsible software. Preserve these relationships when generating embeddings or summaries so a derived artifact can be traced back through intermediate representations.

75. Migrate to a New Embedding Model with Zero Downtime in Qdrant

    Qdrant's migration procedure retains the old representation while populating a new model's vectors from preserved source payloads. Its blue-green option creates a new collection, dual-writes incoming upserts, re-embeds existing points in the background, then switches both collection and query model together. Its named-vector option keeps old and new vectors beside each other until search changes over, permitting rollback while the old vector remains. The new schema separately fixes vector size and similarity function. Source data must remain available because stored vectors alone cannot be re-encoded by a new model.

76. Elasticsearch aliases

    An alias provides a stable name for indexes. A single aliases request can remove the old target and add the rebuilt target atomically. Check action failures and use must_exist where appropriate to prevent a partial action list from producing an unintended switch. A write alias targeting multiple indexes needs an explicit write index. Application inference: validate the new generation and catch it up before switching; retain the previous index for a reverse alias operation. Coordinate the generation with query-embedding model, dimensions, similarity settings, schema, chunk IDs, source-span mappings, ACL metadata and caches so requests use compatible artifacts.

77. How LLMs work for Web Devs: GPT in 600 lines of Vanilla JS

    In the co-occurrence example, cosine similarity preserves similarity of relative context patterns despite differences in word frequency.

78. How LLMs work for Web Devs: GPT in 600 lines of Vanilla JS

    The demonstrated language head scores vocabulary tokens using the token embedding matrix, then chooses the largest score for deterministic comparison with another GPT-2 implementation.