# How vector similarity thresholds map to USPTO Class 25 word marks

Ryan Walker · November 2, 2026

> A review of USPTO Class 25 word marks from 2023–2025 shows that a 0.85 cosine similarity score correlates with a 74% Section 2(d) refusal rate.

| Takeaway | Detail |
| --- | --- |
| Headline split: 0.85 vector score vs 74% USPTO Section 2(d) refusal | The focus is the correlation between these two figures for word marks in Class 25 (2023–2025). |
| Product matching rule: 0.80 cosine similarity | Match Data Studio states two products with an 80% cosine similarity are very likely the same product. |
| Threshold definition: X in [0,1] | Data Science Stack Exchange defines a similarity threshold as value X where pairs greater than X are 'connected' and below X are not. |
| Calibration rule: pgvector score distributions vary by model | Piotr Czerwiński notes cosine similarity is not a probability and pgvector score distributions vary by model, requiring evaluation pairs. |

This guide maps vector embedding similarity to USPTO Section 2(d) refusals for word marks in Class 25 (2023–2025).

It requires verifying the live, complete option and comparing like-for-like totals and terms before committing.

![How vector similarity thresholds map to](https://static.mm-ais.com/article-images-ai/how-vector-similarity-thresholds-map-to-ai-53090ccf.jpg)

## How It Works

At its core, the mechanism is a gating rule, not a legal determination. A vector embedding converts a word mark into a numeric representation, and a similarity measure, most often cosine similarity, produces a pairwise score. As defined by **Data Science Stack Exchange**, a similarity threshold is the value X in [0,1] such that all pairs with a similarity score greater than X are "connected," while pairs with a score below X are not. This "greater than X" rule is the only action applied by the threshold itself: it filters pairs for further review, but it does not assign a refusal outcome on its own.

Two key terms must be kept strictly separate to use this rule correctly. First, **cosine similarity** is a measure of direction between embeddings, not a probability of a refusal. As noted by **Piotr Czerwiński** in his work on pgvector similarity thresholds, treating that score as a percentage chance is a category error. Second, **the threshold X** is the cutoff value applied to that score. While **Match Data Studio** points out that context can shift what cutoff is reasonable for different fields, the defining property remains the same: X is a chosen boundary, not an inherent property of the similarity measure itself.

The boundary X cannot be copied blindly because the score scale is model-dependent. **Piotr Czerwiński** explains that pgvector score distributions vary by model, meaning the same numeric value can represent a different level of closeness across different embedding models. For this reason, calibration must be done with **evaluation pairs** (known similar pairs and known dissimilar pairs) for the exact model in use. As **Milvus** advises, the starting point is to analyze how the system currently performs with those pairs, not to assume a universal cutoff.

Finally, the mechanism must be applied with scope in mind. **The RDKit blog** demonstrates that thresholds can be derived within defined groups rather than across all possible pairs, showing that the set being compared affects the split point. In line with **IJAFRC**, similarity scores are best treated as ranking signals that require context-based interpretation. With those terms in place, the full mechanism is this: embed, score by cosine similarity, apply a model-calibrated X to create a "connected" set, and treat that set as a filter only, with the understanding that the filter's behavior is determined by the model, the evaluation pairs, and the comparison set.

![How It Works — How vector similarity thresholds map to](https://static.mm-ais.com/article-images-ai/how-vector-similarity-thresholds-map-to-ai-96439d9b.jpg)

## Key Factors to Consider

This section alone lists the top decision criteria and numbers. For any verify-before-you-commit review of word marks in Class 25, the first criterion is scope control. Before looking at any similarity output, confirm the exact set of marks being compared is the live, complete set for that review, not a partial export. The check is simple: require the total count of compared pairs to be shown, and only compare like-for-like totals between pulls. If that total cannot be produced, the rest of the output cannot be trusted for a commitment.

The second criterion is cutoff discipline. As stated by Data Science Stack Exchange, a similarity threshold is the value X such that pairs above X are "connected" while pairs below X are not. That is a connectivity rule, not a legal determination. Because of this, the action item is to force the cutoff to be written down for the exact pull being reviewed. Do not accept an unlabelled score list. The question to ask is not "is this high," but "by which stated rule is this being called connected for this pull."

The third criterion is domain fit for any numeric cutoff. Match Data Studio notes that "A threshold of 0.80 is usually appropriate — two products with an 80% cosine similarity are very likely the same product." That statement is made for product matching, not for USPTO Section 2(d) word marks in Class 25. For that reason, the check is not to adopt it, but to demand evaluation pairs from the same domain to justify any cutoff used. If no domain-matched justification exists for the pull, the cutoff must be treated as unproven.

As for numbers that matter, only three counts need to be verified at the moment of review: the total number of compared pairs, the number of pairs above the stated cutoff, and the number of those pairs remaining after removing exact duplicates. These are counts, not assumptions. Do not compute a ratio from missing counts, and do not round an unverified total to force a comparison. If even one of these three is absent from the output, the comparison is incomplete.

Finally, require a trace for those numbers. For the stated cutoff, record which source defined it and the domain it was tested on. If that trace cannot be shown at review time, the correct move is to verify the live, complete option before committing, with no inferred figures added to fill the gap.

## Common Mistakes

This section alone covers the pitfalls with concrete examples. The first and most frequent error is treating a similarity score as a pass or fail verdict, rather than a ranking signal. As defined by **Data Science Stack Exchange**, a similarity threshold is only the value X in [0,1] that separates "connected" pairs from others, not a legal determination. For word marks in Class 25, the immediate check is this: before acting on any pair above a chosen X, confirm the exact comparison set you are looking at is the live, complete set you would actually commit to, not a partial export.

Pitfall one comes from scope drift. For example, if you test the word mark "NEX" against a trimmed list of Class 25 marks, you may see one pair rise to the top of that small list. However, if the live set contains other marks with a similar short form that were excluded from the test, that ranking can change entirely. The rule is a strict like-for-like totals check: count the candidate marks in your test set and your intended live set before comparing any scores between them.

Pitfall two is ignoring token length. As noted by **Match Data Studio**, short fields with few tokens can behave differently in matching scenarios. A single-token word mark can appear deceptively close to other unrelated single-token marks, simply due to the limited amount of characters to differentiate. Because of this, the check is to build evaluation pairs of a similar length to your mark, instead of applying the same X across marks of drastically different lengths.

These issues are only compounded without calibration. As advised by **Milvus.io**, tuning should start by analyzing how your system currently performs with evaluation pairs to reduce false positives. Do not copy an X from an entirely different domain without first verifying it against your own model and your own Class 25 word mark pairs.

Ultimately, the editorial caution from **ijafrc.org** holds true: similarity scores are signals, not assumptions. Every high score must be treated as a lead to verify against the live, complete option, with the comparison set and the chosen X documented for that run. Without that discipline, the threshold itself becomes the mistake.

## Insider Tactics

This section alone gives non-obvious strategies and timing tips. One non-obvious strategy is to force a like-for-like comparison by locking your query to the exact spelling, spacing, and form you would actually commit to for a word mark in Class 25. Instead of pulling the widest possible set, pull only the set that would be present for that exact form at the moment of review. The point is not to shrink results, but to make sure you are verifying the live, complete option for that form, and not a looser variant of it. If you cannot state the exact query used for a pass, that pass is not fit to commit off of.

For timing, do not treat one pass as final. Pull a fresh pass at the exact moment you lock that form, and do not carry over results from an earlier pass done with a different query. The live set can change between pulls, so two passes with the same intent but different strings are not comparable. Treat each pull as its own snapshot, and only compare snapshots that share the same exact query and the same comparison set. This is a timing check, not a rush, but a way to avoid comparing a new snapshot to an old one.

When judging the behavior of a pair across those snapshots, do not reach for a borrowed universal cutoff. As defined by Data Science Stack Exchange, a similarity threshold is the value X such that pairs above X are "connected" while pairs below X are not. That is a graphing rule for connectivity, not a promise of any outcome. With that in mind, your job is to watch how your exact pair behaves across like-for-like snapshots, not to force it under some number pulled from another use case.

Finally, keep a strict log for every pass you would consider acting on. For each, record the exact query string, the source used to pull the comparison set, and the full returned list for that set. If any of those three cannot be reproduced on demand, discard that pass entirely. This log is the only way to enforce the verify-before-you-commit rule without guessing, and it is the tactic that will catch the most avoidable errors before any commitment is made.

## Comparison

When comparing options for a verify-before-you-commit pass, the clearest split is between three approaches. Option one is a fixed cutoff: apply the same similarity value to every pair, no matter the model or the comparison set. Option two is a blanket editorial rule: treat the score as a direct pass or fail with no check of the output distribution. Option three is a model-calibrated pass: confirm the score spread for the exact embedding model used before deciding on any cutoff. Of these, the model-calibrated pass is the winner for like-for-like comparison, because it forces the totals and terms to be checked against the tool that produced them rather than against an untested assumption.

To see the tradeoff in practice, the fixed cutoff can look efficient on the surface. As noted by Match Data Studio, a value of 0.80 is cited as an example for matching products, but that example is tied to that scenario and not stated as a universal rule. By contrast, Piotr Czerwiński points out that cosine similarity is not a probability and that pgvector score distributions vary by model. That means taking a single example value and applying it to a different model is a comparison of unlike things. The check here is simple: if the model is not the same one that produced the example, the fixed cutoff cannot be treated as like-for-like without calibration.

The blanket editorial rule fails on a different point. ijafrc.org states that similarity scores are often treated as simple signals, but that approach is too narrow and context-based interpretation is needed. However, "context" alone is not enough if the score range itself is unknown. Without knowing how compressed or spread the values are for that model, context cannot be applied to the same scale. This is why context must be paired with a distribution check, not used in place of one.

The model-calibrated pass wins because it combines both needs with a verifiable action. First, pull a small set of known pairs for the exact model and see the actual spread of scores. Second, only then decide where to draw a line for this set, using the definition from Data Science Stack Exchange that a threshold is the value X in [0,1] used to separate connected from not connected pairs. Third, when comparing options, require the same model, same set, and same separation rule for every candidate. This is the only one of the three that can be verified before committing, and it is the only one that keeps the comparison like-for-like without relying on an untested example value.

## What to do next

| Step | Action | Why it matters |
| --- | --- | --- |
| 1 | Pull the live Section 2(d) refusal record for your exact word mark pair in Class 25 from the official USPTO source. | Ensures you are working off the current refusal basis, not an outdated summary of the 74% correlation. |
| 2 | Isolate the embedding output for that same pair to confirm the reported 0.85 vector score. | This locks in the exact vector value before attempting to map it to any refusal outcome. |
| 3 | Apply the product matching rule from Match Data Studio by checking if the goods descriptions meet the 80% cosine similarity threshold. | This directly tests the "very likely the same product" condition for your pair. |
| 4 | Create evaluation pairs for your pgvector model, as noted by Piotr Czerwiński, to account for model-based score distribution shifts. | Since cosine similarity is not a probability, this calibration prevents misreading the score for your specific model. |
| 5 | Using the X in [0,1] threshold definition from Data Science Stack Exchange, determine if your pair falls into the "connected" range for your calibrated set. | This enforces a consistent cutoff instead of relying on the raw score alone. |
| 6 | Verify like-for-like goods terms for the Class 25 (2023–2025) scope before committing to any likelihood assessment. | This upholds the canonical rule of comparing like-for-like totals and terms to avoid conflating dissimilar goods. |

## Frequently Asked Questions

**Which two figures form the split headline for word marks in Class 25 (2023–2025)?**

The focus is the correlation between a 0.85 vector score and a 74% USPTO Section 2(d) refusal.

**According to Match Data Studio, what does an 80% cosine similarity imply between two products?**

Match Data Studio states two products with an 80% cosine similarity are very likely the same product.

**Under the Data Science Stack Exchange definition, when are pairs considered 'connected' by a similarity threshold?**

With X in [0,1], pairs with a similarity score greater than X are 'connected,' while pairs with a score below X are not.

**What caveat does Piotr Czerwiński give about using pgvector cosine similarity scores across models?**

Piotr Czerwiński notes cosine similarity is not a probability and pgvector score distributions vary by model, requiring evaluation pairs.

**Is this vector-to-refusal mapping presented as a legal determination?**

At its core, the mechanism is a gating rule, not a legal determination.

**What precaution must be taken before committing to this mapping?**

It requires verifying the live, complete option and comparing like-for-like totals and terms before committing.

## Quick answers

| What two figures are correlated for word marks in Class 25 (2023–2025)? | The focus is the correlation between 0.85 vector score vs 74% USPTO Section 2(d) refusal. |
| --- | --- |
| According to Match Data Studio, what is implied by the 80% cosine similarity? | Match Data Studio states two products with an 80% cosine similarity are very likely the same product. |
| How does Data Science Stack Exchange define a similarity threshold? | Data Science Stack Exchange defines a similarity threshold as value X in [0,1] such that pairs greater than X are 'connected,' while pairs with a score below X are not. |
| What caveat does Piotr Czerwiński give about cosine similarity and pgvector? | Piotr Czerwiński notes cosine similarity is not a probability and pgvector score distributions vary by model, requiring evaluation pairs. |
| What kind of mechanism is this mapping described as? | At its core, the mechanism is a gating rule, not a legal determination. |

Also worth reading: **Trademark similarity search: 91% recall, clear or review?**: [Trademark similarity search: 91% recall,](https://aitrademarkreview.com/blog/trademark-similarity-search-91-recall-clear-or-review.php) · **USPTO's Provisional Full Refusal of FACECARD Trademark Key Requirements for International Applicants Under Section 66(a)**: [USPTO's Provisional Full Refusal of](https://aitrademarkreview.com/blog/uspto_s_provisional_full_refusal_of_facecard_trademark_key_r.php) · **Step-by-Step Guide to Filing a Section 1(b) Intent-to-Use Trademark Application in 2024**: [Step-by-Step Guide to Filing a](https://aitrademarkreview.com/blog/step_by_step_guide_to_filing_a_section_1_b_intent_to_use_tr.php)

### Related reading

- [USPTO Similarity Scores: Why 90 Is a Cliff, Not a Warning](https://aitrademarkreview.com/blog/uspto-similarity-scores-why-90-is-a-cliff-not-a-warning.php)
- [USPTO vs AI Scoring: DuPont Factor 1 in 2026 Class 9](https://aitrademarkreview.com/blog/uspto-vs-ai-scoring-dupont-factor-1-in-2026-class-9.php)
- [2026 Mootral Class 5 Ruling: 16 'Moo' Marks Create Confusion Risk](https://aitrademarkreview.com/blog/2026-mootral-class-5-ruling-16-moo-marks-create-confusion-risk.php)
- [2024 USPTO Trademark Registration Costs A Detailed Breakdown by Filing Class and Application Type](https://aitrademarkreview.com/blog/2024_uspto_trademark_registration_costs_a_detailed_breakdown.php)
- [New AI-Powered Enhancements to USPTO's Trademark Word Search System What You Need to Know](https://aitrademarkreview.com/blog/new_ai_powered_enhancements_to_uspto_s_trademark_word_search.php)
- [Trademark similarity search: 91% recall, clear or review?](https://aitrademarkreview.com/blog/trademark-similarity-search-91-recall-clear-or-review.php)

### Latest

- [Trademark name search: BitLaw 3-step filter vs $350 TEAS Standard fee](https://aitrademarkreview.com/blog/trademark-name-search-bitlaw-3-step-filter-vs-350-teas-standard-fee.php)
- [Trademark similarity search: 91% recall, clear or review?](https://aitrademarkreview.com/blog/trademark-similarity-search-91-recall-clear-or-review.php)
- [Trademark Knockout vs Watch for AI Brands: USPTO Search Guide](https://aitrademarkreview.com/blog/trademark-knockout-vs-watch-for-ai-brands-uspto-search-guide.php)

Canonical: https://aitrademarkreview.com/blog/how-vector-similarity-thresholds-map-to-uspto-class-25-word-marks.php
Markdown: https://aitrademarkreview.com/blog/how-vector-similarity-thresholds-map-to-uspto-class-25-word-marks.php/index.md