Disambiguating USE/USeR: A Three-System Overview

• Usees are distinct systems sharing the USE/USeR acronym while addressing user behavior modeling, image segmentation, and agile user story quality.
• The dynamic user modeling USE employs a stateful RetNet with exact embedding updates, achieving superior metrics like 95.0 AUC and 58.31 MRR compared to baselines.
• The universal segment embeddings USE integrates CLIP and DINOv2 for open-vocabulary segmentation and USeR utilizes interpretable metrics and REST APIs for agile story optimization.

Searching arXiv for the cited papers to ground the article in the current record. arXiv search: (Zhou et al., 2024) In recent arXiv literature, the acronym USE and the related tool name USeR denote three unrelated systems in distinct technical domains: User Stateful Embedding for dynamic behavior-based user modeling, Universal Segment Embeddings for open-vocabulary image segmentation, and User Story eReviewer for assisted quality optimization of agile user stories (Zhou et al., 2024, Wang et al., 2024, Hallmann et al., 3 Mar 2025). Taken together, these works illustrate how the same lexical form is used for sequence representation learning, vision–language alignment, and requirements-engineering analytics, but with different problem formulations, architectures, objectives, and evaluation protocols.

1. Nomenclature and scope

The 2024–2025 record contains two papers titled “USE” and one paper titled “USeR”. The first USE is a framework for learning general-purpose user embeddings from behavioral logs that can be updated efficiently as new behavior arrives, without reprocessing the entire user history (Zhou et al., 2024). The second USE is a framework for open-vocabulary image segmentation that learns a universal segment embedding aligned with text-defined categories (Wang et al., 2024). USeR is a web-based tool for assessing and improving the quality of agile user stories through interpretable metrics and a RESTful API (Hallmann et al., 3 Mar 2025).

Name	Domain	Core mechanism
USE	Dynamic user modeling	Stateful RetNet with FBP and SUP
USE	Open-vocabulary image segmentation	Segment–text contrastive learning over CLIP + DINOv2 features
USeR	User story quality assessment	Rule-based and ML-based metrics exposed through web UI and REST API

These systems are not variants of a single research line. Their commonality lies primarily in abbreviation rather than methodology. A plausible implication is that any encyclopedic treatment of “Usees” must be disambiguating rather than unifying: each work addresses a different representational unit—user behavior sequences, image segments, or textual requirements artifacts.

2. USE as dynamic behavior-based user modeling

User Stateful Embedding models a user $u^k$ as a time-ordered behavior sequence

$$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$

where $\mathcal{B}$ is the set of behavior types. The central problem is dynamic user modeling: user embeddings should reflect both long-term traits and short-term state, while remaining periodically updateable as new behaviors arrive (Zhou et al., 2024).

The paper frames stateless sequence models such as Transformers as computationally problematic in this setting. They must either use only recent data, pool per-period embeddings, or recompute the full concatenated sequence at every update. The last option is the information-preserving baseline, but its cost grows with history length and yields total cost proportional to $T^2$ over $T$ periods when each period contributes a constant number of events (Zhou et al., 2024).

USE addresses this by coupling a stateful sequence model with an exact embedding update rule. The encoder is a RetNet with 12 Retention layers, 8 retentive heads, hidden size 768, and intermediate size 3072. At a period boundary $p_0$, the model processes $\mathbf{x}_{p_0}=[x_1,\dots,x_{p_0}]$ from initial state $\mathbf{s}_0=\mathbf{0}$, producing hidden states $h_1,\dots,h_{p_0}$, a final state $\mathbf{s}_{p_0}$, and the mean-pooled user embedding

$$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$0

When new behaviors $$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$1 arrive, USE reuses the stored state $$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$2, computes the mean of new hidden states

$$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$3

and updates the full embedding through the length-weighted average

$$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$4

This is mathematically identical to recomputing the mean over all hidden states for the concatenated sequence, but its update cost depends only on the new chunk rather than the full history (Zhou et al., 2024).

The statefulness comes from RetNet’s retention operator. Instead of softmax attention, it uses

$$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$5

with recurrent state

$$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$6

This yields recurrent inference with constant per-token cost with respect to history length while remaining equivalent to the parallel retention computation (Zhou et al., 2024).

USE is pretrained with two objectives. Future $$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$7-Behavior Prediction (FBP) predicts which behavior types will occur at least once within a future window, treating the target as binary multi-label classification rather than exact next-token prediction. The paper typically sets $$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$8, and an ablation reports that $$\mathbf{x}^k = [x_1^k, x_2^k, \ldots, x_n^k],\quad x_i^k \in \mathcal{B},$$9 and $\mathcal{B}$0 perform best for User Retrieval, whereas larger windows such as 500 and 1000 degrade performance (Zhou et al., 2024). Same User Prediction (SUP) uses a SimCLR-style contrastive loss over two non-overlapping subsequences from the same user, with cosine similarity and in-batch negatives, to promote discriminative, user-specific embeddings (Zhou et al., 2024).

Empirically, USE was evaluated on Snapchat behavioral logs with 685 distinct behavior types plus a “new_session” marker. In the static setting, the combined USE model achieved the best average performance across six downstream tasks, with average score 78.0, compared with 75.3 for Trans-CLM, 75.8 for USE-FBP, and 77.6 for USE-SUP. On User Retrieval, USE reached 47.4 versus 33.2 for Trans-CLM. On Locked Account Prediction it achieved 95.0 AUC, on Ads View Time Prediction 90.4 AUC, and on Account Self-deletion Prediction 64.5 AUC (Zhou et al., 2024).

In the dynamic setting, users began with 250 behaviors and accumulated 250 more per period over 15 periods. For full USE, Next-Period Behavior Prediction yielded average AUC 77.73 with stateful updates, compared with 74.59 for Pool Embeddings and 70.74 for Recent Only. In User Re-Identification, average MRR was 58.31 for stateful USE, 56.79 for Pool Embeddings, and 38.49 for Recent Only (Zhou et al., 2024). The computational claim is equally central: Recompute All has per-update cost $\mathcal{B}$1 and total cost $\mathcal{B}$2, whereas USE has per-update cost $\mathcal{B}$3 and total cost $\mathcal{B}$4 when the new chunk size is constant (Zhou et al., 2024).

3. USE as universal segment embeddings for open-vocabulary image segmentation

The second USE, Universal Segment Embeddings, addresses open-vocabulary image segmentation by separating segment proposal from segment classification. The starting assumption is that SAM can generate high-quality class-agnostic masks, so the remaining bottleneck is accurate classification of arbitrary segments into text-defined categories (Wang et al., 2024).

USE treats each segment as a “mini-image” and maps it into a CLIP-like shared vision–language space. Its pipeline has two major components: a data pipeline that constructs large-scale segment–text pairs at multiple granularities, and a universal segment embedding model trained by segment–text contrastive learning (Wang et al., 2024).

The data pipeline supports image-only datasets, image-caption datasets, and datasets with image–phrase grounding boxes. It performs three stages: multi-granularity image captioning, referring expression grounding, and mask generation from boxes. In captioning, the paper uses multimodal LLMs such as CogVLM-17B, Kosmos-2, or LLaVA, with a prompt that explicitly requests all visible parts of each object. In experiments, it primarily uses CogVLM-17B with temperature 0.8, top-p 0.4, and top-k 5 (Wang et al., 2024).

For grounding, noun phrases are extracted with spaCy, expanded through dependency parsing into richer referring expressions, and localized with Grounding DINO or CoDet. A key design choice is to query Grounding DINO with the entire caption once, rather than with isolated short phrases, so that contextual relations such as “face of the rabbit” or “apple behind the rabbit” remain available (Wang et al., 2024). Bounding boxes are then converted into masks by SAM ViT-H; the mask with the highest stability score is selected, small holes are filled, small isolated components are removed, and mask NMS with IoU threshold 0.7 merges duplicates (Wang et al., 2024).

The resulting data scale is large. On COCO, the pipeline yields 5.6M raw segment–text pairs, 1.3M after mask NMS, and 0.9M unique expressions. On Visual Genome, it yields 5.0M raw pairs, 2.9M after NMS, and 3.1M unique expressions. For comparison, OVSeg’s COCO data comprises 1.3M segment–text pairs and about 0.3M expressions (Wang et al., 2024).

The model combines frozen CLIP ViT-L/14 and DINOv2 ViT-L/14 visual backbones. CLIP patch embeddings from all transformer blocks and DINOv2 patch embeddings from only the last $\mathcal{B}$5 blocks are passed through LayerNorm–Linear modules and merged by learned block scales. The final patch-wise representation is

$\mathcal{B}$6

where $\mathcal{B}$7 and $\mathcal{B}$8 are merged patch features and $\mathcal{B}$9 are global cls-token embeddings (Wang et al., 2024). Given a mask $T^2$0, USE computes patch weights $T^2$1 from the fraction of each patch covered by the segment, performs mask pooling

$T^2$2

and projects the result with a linear layer: $T^2$3 The text side uses the CLIP text encoder, and training applies a symmetric InfoNCE-style segment–text contrastive loss with temperature $T^2$4 (Wang et al., 2024).

At inference time, SAM produces masks from a regular point grid, USE encodes each segment, class names are turned into prompts such as “a photo of {class}” or “There is {class} in the scene,” and segment–text similarities are converted into per-segment class probabilities through a softmax over categories. Pixel-level semantic maps are obtained by aggregating over all segments covering each pixel (Wang et al., 2024).

USE was trained for 5 epochs with batch size 32, AdamW, learning rate 0.001, polynomial decay with power 0.9, weight decay 0.01, random resize with scale 0.5–2, and random crop $T^2$5 (Wang et al., 2024). In zero-shot semantic segmentation, USE+SAM trained on COCO and Visual Genome segment–text pairs achieved mIoU 37.0 on ADE-150, 13.3 on ADE-847, 57.8 on PC-59, and 14.7 on PC-459, for average 30.7. This exceeds OVSeg+SAM at 24.9 average and surpasses SAN’s average 29.4 (Wang et al., 2024).

The paper also reports open-vocabulary part segmentation on PartImageNet. USE, trained without PartImageNet or human-annotated parts, reaches $T^2$6 over all 40 parts. On the quadruped subset, it reports head 8.8, body 2.6, foot 2.6, and tail 18.5 (Wang et al., 2024). Ablations show that combining CLIP and DINOv2 improves over either alone, and that including cls tokens gives a slight mIoU improvement (Wang et al., 2024).

4. USeR as a system for agile user story quality optimization

USeR, or User Story eReviewer, is a web-based tool for assessing and improving user story quality in agile software development (Hallmann et al., 3 Mar 2025). Its design premise is that user stories are the de facto requirements artifact in many agile projects, but authors frequently write low-quality stories and available tools often emphasize syntactic heuristics without capturing semantic aspects or providing coherent, interactive feedback (Hallmann et al., 3 Mar 2025).

The work begins from a broad inventory of quality criteria. Through literature review, practitioner sessions, and research group meetings, the authors collected 77 potential metrics. Two Delphi sessions refined these to 34 applicable metrics, and eight were implemented first: Format Complete, Readable, Customer Speak, Small, Independent, Word Sparse, Sentence Sparse, and Easy Language (Hallmann et al., 3 Mar 2025).

Architecturally, USeR consists of a Node.js and React web app, a Python RESTful API, and a Docker-based deployment environment. Internally, the API performs data import, training, prediction, and interpretation. It uses spaCy for tokenization, sentence splitting, similarity, NER, and lemmatization; scikit-learn for TF-IDF and SVM; and BERTopic for topic modeling (Hallmann et al., 3 Mar 2025).

Several metrics are formalized explicitly. Format Complete measures the proportion of filled patterns among {title, persona, what, why, acs, attachments}: $T^2$7 It combines regex and position heuristics with TF-IDF and SVM-based detection where explicit structure is missing (Hallmann et al., 3 Mar 2025).

Customer Speak is defined as

$T^2$8

where $T^2$9 is the number of glossary words and $T$0 the number of unique words. The glossary is constructed from the project backlog via TF-IDF, NER, and lemmatization (Hallmann et al., 3 Mar 2025). Small estimates topical concentration using BERTopic topic probabilities: $T$1 Independent approximates dependency through average cosine similarity to all backlog stories: $T$2 Easy Language is

$T$3

with $T$4 the number of words from a curated German basic vocabulary list (Hallmann et al., 3 Mar 2025). Readability is computed using the German Flesch index, and Word Sparse and Sentence Sparse are derived from project-level min/mean/max word and sentence counts (Hallmann et al., 3 Mar 2025).

The UI exposes these scores on a 0–100% scale, color-coded by project-specific percentiles. The tool thus supports an iterative loop: write or paste a story, evaluate it, inspect metric-level explanations, revise the story, and reevaluate (Hallmann et al., 3 Mar 2025).

Evaluation used two real-world projects: an automotive project with 815 user stories and a health project with 150 stories. Four experts rated 100 sampled stories using a five-point Likert scale. After IQR-based outlier removal, the retained datasets comprised 42 automotive stories and 39 health stories. Inter-rater reliability was $T$5 for automotive and weighted $T$6 for health (Hallmann et al., 3 Mar 2025). Multiple linear regression yielded $T$7 for automotive, $T$8 for health, and $T$9 globally. Across settings, Format Complete and Word Sparse were the most robust predictors, while Small showed a negative relation to expert ratings in these data (Hallmann et al., 3 Mar 2025).

5. Comparative structure across the three systems

The three systems share a representational core but differ in the entity being represented and in the surrounding task interface. User Stateful Embedding represents a user through a behavior sequence and a persistent recurrent state; Universal Segment Embeddings represents a segment mask through pooled patch features aligned to text; USeR represents a user story artifact through a vector of interpretable quality metrics (Zhou et al., 2024, Wang et al., 2024, Hallmann et al., 3 Mar 2025).

A further distinction is their supervision regime. Dynamic user modeling uses self-supervised predictive and contrastive objectives over behavioral logs; the segment-embedding USE uses automatically curated segment–text pairs and bi-directional contrastive alignment; USeR combines rule-based features with supervised or semi-supervised project-specific models such as SVM and BERTopic (Zhou et al., 2024, Wang et al., 2024, Hallmann et al., 3 Mar 2025). This suggests a broad family resemblance at the level of representation learning and modular deployment, but not at the level of problem semantics.

Their deployment assumptions are also different. User Stateful Embedding is positioned for large-scale personalization systems in which users generate many events per day and embeddings must be refreshed regularly (Zhou et al., 2024). Universal Segment Embeddings is designed as a decoupled classification layer that can attach to SAM or other class-agnostic segmenters (Wang et al., 2024). USeR is intended for agile workflow integration through a web interface and REST API, with potential future clients such as mobile apps and Jira plugins (Hallmann et al., 3 Mar 2025).

6. Limitations and research directions

Each system inherits limitations from its modality and evaluation setting. The user-modeling USE relies purely on behavior sequences and does not address cold-start users explicitly; it also depends on sensitive behavioral logs and requires careful privacy handling. Its authors note that larger RetNet models could improve representation capacity at additional training and inference cost, and that hyperparameters such as the FBP window size $p_0$0 and SUP temperature matter materially (Zhou et al., 2024).

The segmentation USE depends on the segment proposal mechanism. When SAM cannot produce masks at the appropriate granularity—such as very small objects or ambiguous part boundaries—the embedding model cannot recover the correct label. The experiments focus on natural images, and domain shift to settings such as medical or satellite imagery is not studied (Wang et al., 2024).

USeR is limited by domain and language specificity. The empirical study covers only two German-speaking domains, and metrics such as Customer Speak and Easy Language depend on project glossaries and German-specific lexical resources. Only 8 of 34 prioritized metrics were implemented, leaving areas such as testability, traceability, and volatility for future work (Hallmann et al., 3 Mar 2025).

A plausible synthesis is that these three “USE/USeR” systems exemplify a common contemporary pattern in applied machine learning: each builds a compact representation that is not an end in itself, but a reusable intermediate object for downstream decision support. In one case the downstream interface is periodic embedding refresh for personalization, in another zero-shot segment classification by text prompts, and in the third iterative requirements-quality optimization by interpretable metric feedback (Zhou et al., 2024, Wang et al., 2024, Hallmann et al., 3 Mar 2025).