From Pixels to Semantic Coordinates: Vehicle Recognition over Narrowband Internet of Things with Link-Adaptive Progressive Transmission

2.1 Problem definition and overall idea

This paper studies the problem of traffic image processing and vehicle recognition in the NB-IoT narrowband uplink scenario. Let the edge device collect a traffic image $x_t \in \mathrm{R}^{H \times W \times 3}$ in the $t$-th time slot, and obtain a set of vehicle regions $\left\{\left(b_i, p_i\right)\right\}_{i=1}^{N_t}$ through a lightweight detector, where $b_i$ is the bounding box of the $i$-th vehicle and $p_i$ is the detection confidence. The available NB-IoT uplink budget is denoted as $B_t$, and the link state is denoted as $Q_t=\left\{\mathrm{SNR}_t, \mathrm{RSRP}_t\right.$, retrans$\left._t, P_t\right\}$, where $\mathrm{SNR}_t$ is the signal-to-noise ratio (SNR), $\mathrm{RSRP}_t$ is the reference signal received power (RSRP), retrans$_t$ is the number of retransmissions, and $P_t$ is the available application-layer payload budget of the current time slot. This problem does not aim at transmitting raw images, JPEG compressed frames, or generic deep feature maps; instead, each vehicle region is encoded into quantizable, rankable, and queryable semantic coordinates of vehicle identity $q_i$, and the cloud completes vehicle classification and re-identification relying only on $q_i$ and the scene context $s_i$. The overall optimization objective is written as:

$\begin{gathered}\min _{\theta, \phi, \pi, \psi} E\left[L_{c l s}+\lambda_I L_{\text {reid}}+\lambda_2 L_{\text {quant}}+\lambda_3 L_{c t x}+\lambda_4 R(B)+\lambda_5 L_{f b}\right] \\ \text { s.t. } \sum_{i, t} b_{i, t} \leq B_{\text {total}}, b_{i, t} \leq B_{p k t}\left(Q_t\right), q_i=Q\left(E\left(x_t, b_i\right)\right)\end{gathered}$

where, $\theta, \phi, \pi, \psi$ correspond to the learnable parameters of the semantic encoding, saliency prediction, transmission policy, and feedback refinement modules, respectively; $L_{\text {cls}}$ is the vehicle classification loss, $L_{\text {reid}}$ is the vehicle re-identification loss, $L_{\text {quant}}$ is the quantization loss, $L_{\text {ctx}}$ is the context consistency loss, $R(B)$ is the transmission cost, $L_{\mathrm{fb}}$ is the feedback refinement loss, and $\lambda_1$ to $\lambda_5$ are the weights of the respective losses. $E()$ is the edge semantic encoder and $Q()$ is the quantizer; $b_{i, t}$ is the uplink bits actually occupied by the $i$-th vehicle, $B_{\text {total}}$ is the total uplink budget, and $B_{\mathrm{pkt}}\left(Q_t\right)$ is the number of bits that a single packet can carry under the current link state. This objective does not simply pursue classification accuracy, but maximizes the vehicle identity discriminative capability under the constraints of the NB-IoT transmission budget and link fluctuation.

The overall idea is to treat the NB-IoT bandwidth constraint as a semantic selection problem rather than a mere compression problem. What vehicle recognition truly needs is identity discriminative information such as vehicle type, color, brand, texture salient regions, and local structure, whereas background, illumination, and global texture redundancy contribute little to identity discrimination. To this end, this paper takes the discriminative gain for vehicle identity $\alpha_{i, k}$ as a unified variable that runs through the three stages of semantic encoding, progressive transmission, and feedback refinement. $\alpha_{i, k}$ denotes the gain of the $k$-th semantic block of the $i$-th vehicle for vehicle identity discrimination given the preceding semantic blocks; a higher value means that this semantic block should be transmitted or refined with higher priority. In the encoding stage, semantic blocks are organized according to $\alpha_{i, k}$; in the transmission stage, limited bits are allocated according to $\alpha_{i, k}$; in the feedback stage, the semantic direction that needs to be supplemented is determined according to the cloud recognition uncertainty. As a result, the vehicle identity discrimination requirement is no longer confined to the cloud classifier, but is advanced into edge encoding and link transmission decisions, so that the limited uplink budget is concentrated on the most discriminative semantic components.

2.2 Framework overview

The overall pipeline consists of four stages, including edge-side vehicle detection and Region of Interest (ROI) extraction, semantic coordinate encoding of vehicle identity and semantic block organization, link-state-aware progressive transmission, and cloud-side progressive recognition and feedback refinement. As shown in Figure 1, this system constructs a complete closed-loop architecture from edge front-end processing to narrowband transmission, and then to cloud inference and downlink control. At the edge, a lightweight backbone network is first used to extract multi-scale features, and ROIAlign is adopted to obtain the region feature of each vehicle. Subsequently, the dual-branch semantic encoder outputs the appearance identity embedding and the scene context embedding, respectively. After the appearance identity embedding undergoes normalization, quantization, and semantic block partitioning, the saliency prediction head estimates the discriminative gain α_ik of each semantic block, forming a semantic block priority queue sorted in descending order of discriminative gain. The transmission layer prioritizes the transmission of semantic blocks with high discriminative gain according to the NB-IoT link state Q_t and the currently available budget B_t, and adaptively allocates the quantization bit width, so that key vehicle attributes remain recognizable when the link degrades, and the re-identification accuracy is further improved when the link is in good condition.

Figure 1. Overall framework of edge–cloud collaborative vehicle semantic progressive transmission and feedback refinement

After receiving part of the semantic blocks, the cloud performs masked progressive classification and re-identification, and computes the classification uncertainty and the gallery-matching ambiguity. If the classification uncertainty is high or the matching with the vehicle gallery is ambiguous, the cloud sends a compact query vector through the downlink narrowband channel, triggering the edge to perform high-resolution re-encoding of the specified vehicle ROI and to send back supplementary semantics. The cloud updates the vehicle recognition result after fusing the supplementary semantics. This process makes the uplink transmission not a one-time fixed output, but a dynamic adjustment according to the cloud recognition state. The three stages share the same discriminative gain variable α_ik, forming a closed loop among encoding, transmission, and feedback, and avoiding the situation where edge encoding and cloud recognition are independent of each other. Through this closed loop, the narrowband constraint of NB-IoT is transformed into a semantic selection mechanism, and the limited uplink bits preferentially carry the semantic information most needed for vehicle identity discrimination, thereby establishing a quantifiable, schedulable, and verifiable unified framework between traffic image processing and vehicle recognition tasks.

2.3 Semantic coordinate encoding of vehicle identity

The edge device has limited computation and power consumption, and a lightweight single-stage detector is adopted for vehicle localization. The detector input resolution is set to 256 × 256 or 384 × 384, and the backbone network uses MobileNetV3-Small or ShuffleNetV2 to reduce the number of parameters and memory access. After non-maximum suppression, the detection output retains vehicle boxes whose confidence is higher than the threshold. For each vehicle box $b_i$, ROIAlign is used to extract a fixed-size region feature $f_i \in \mathrm{R}^{7 \times 7 \times C}$ from the multi-scale feature pyramid. ROIAlign avoids quantization errors and preserves fine-grained structures such as vehicle edges, headlights, and license plate regions. To reduce the burden on the edge device, the detector and the semantic encoder share part of the shallow features and are separated only at the back-end branches. The detection stage does not pursue an extremely high mAP, but guarantees a high recall rate, so that the subsequent semantic encoding covers the main vehicle instances.

On the basis of the region feature, the dual-branch semantic encoder consists of an appearance branch $E_{\text {app}}$ and a context branch $E_{\text {ctx}}$. The appearance branch takes the ROI feature $f_i$ as input and outputs a $d$ -dimensional identity embedding $a_i \in \mathrm{R}^d$. This branch consists of global average pooling, two fully connected layers, and one linear projection, with Gaussian Error Linear Unit (GELU) activation and LayerNorm used in between. To preserve local discriminative structures, lightweight channel attention is introduced before pooling, so that regions such as headlights, grille, and window contours obtain higher weights. The context branch extracts scene semantics such as lane position, driving direction, time period, weather, and camera ID, and outputs a $d_c$-dimensional context embedding $s_i$. The context branch retains only low-dimensional discrete information such as camera ID, lane, and time period, which is counted into the transmission load together with the semantic data and serves as an auxiliary prior for cloud-side classification and re-identification. Figure 2 shows in detail the microscopic network structure and processing flow of the edge encoder, including feature extraction, scalar quantization, and the semantic block ranking mechanism driven by saliency prediction. The appearance embedding is $L_2$-normalized to obtain a unit hypersphere representation:

$z_i=\frac{a_i}{\left\|a_i\right\|_2}$

Normalization stabilizes the quantization error and makes cosine similarity equivalent to Euclidean distance, which facilitates vehicle gallery matching.

Figure 2. Structure of semantic coordinate encoding of vehicle identity and semantic block priority organization

To match the NB-IoT narrowband transmission budget, $z_i$ is quantized into semantic coordinates $q_i$. Let the semantic dimension be $d=64$, which is divided into $K=8$ semantic blocks, each with 8 dimensions. Each semantic block is independently scalar-quantized, and the per-dimension quantization bit width $w_k$ can be adapted between $w_{\min}=4$ and $w_{\max}=16$ bit, corresponding to a per-block payload $b_k=8 w_k$ bit. The quantization process is written as:

$q_i=Q\left(z_i ; B_i\right)=\sum_{k=1}^K q_{i, k} e_k$

where, $q_{i, k}$ is the quantization codeword of the $k$-th semantic block, $e_k$ is the corresponding basis vector, and when all blocks are transmitted, the total semantic payload satisfies $B_i=\sum_{k=1}^K b_k$. When 16-bit quantization is adopted per dimension, the payload of each block is 128 bit, i.e., 16 bytes, and 8 blocks amount to 128 bytes. Block-wise quantization supports progressive transmission and differentiated bit widths; blocks with high discriminative gain can be allocated more bits, while blocks with low gain can be coarsely quantized or delayed for transmission. In actual deployment, each semantic block carries the block index, the quantization codeword, and necessary check information, and the protocol overhead is counted separately in the communication statistics.

Training the semantic coordinates with only the classification loss tends to retain background and illumination information that is irrelevant to vehicle identity. To this end, an information bottleneck constraint is introduced, so that $q_i$ maximizes the predictive capability for the vehicle label $y_i$ while compressing the original region information. Its variational upper bound is:

$L_{\mathrm{IB}} \leq \mathrm{E}_{q_i \sim Q}\left[-\log p\left(y_i \mid q_i\right)\right]+\beta D_{\mathrm{KL}}\left(Q\left(q_i \mid x_i\right) \| p\left(q_i\right)\right)$

where, the first term is the classification likelihood, the second term constrains the quantized posterior $Q\left(q_i \mid x_i\right)$ to be close to the prior $p\left(q_i\right)$, and $\beta$ controls the compression strength. This constraint drives the encoder to discard variation factors irrelevant to identity, such as illumination, weather, and background texture. At the same time, triplet metric learning is adopted to enhance intra-class compactness and inter-class separability:

$L_{\mathrm{reid}}=\sum_i \max \left(0,\left\|q_i^a-q_i^p\right\|_2^2-\left\|q_i^a-q_i^n\right\|_2^2+m\right)$

where, $q_i^a$, $q_i^p$, and $q_i^n$ are the anchor, positive sample, and negative sample semantic coordinates, respectively, and $m$ is the margin. During training, online hard example mining is adopted to preferentially select negative samples that are similar to the anchor but have different vehicle identities, and positive samples that differ greatly from the anchor. This strategy enables the semantic coordinates to retain vehicle identity discriminative capability after NB-IoT low-bit quantization.The cloud classifier takes the semantic coordinates and the context embedding as input:

$\hat{p}_i=\operatorname{softmax}\left(W_c\left[q_i ; s_i\right]+b_c\right)$

The classification loss is:

$L_{\mathrm{cls}}=-\sum_i y_i \log \hat{p}_i$

The quantization loss consists of the reconstruction error and an entropy regularization:

$L_{\text {quant }}=\left\|z_i-q_i\right\|_2^2-\eta H\left(q_i\right)$

where, $W_c$ and $b_c$ are the classifier weight and bias, $y_i$ is the vehicle label, and $H\left(q_i\right)$ is the codeword distribution entropy; a negative entropy term is adopted in the minimization objective to suppress excessive concentration of codewords, and $\eta$ controls the regularization strength. The classification loss guarantees the separability of vehicle categories, the re-identification loss guarantees cross-frame identity consistency, the information bottleneck loss suppresses redundancy, and the quantization loss controls the bit cost. Through joint training, $q_i$ output by the encoder is no longer a generic visual feature, but a compact semantic coordinate oriented to vehicle identity discrimination.

2.4 Discriminative gain estimation and semantic block organization

To determine which semantic blocks should preferentially occupy the limited NB-IoT uplink bits, this paper uses the discriminative gain for vehicle identity as the basis for semantic block ranking. For the $k$-th semantic block $q_{i, k}$ of the $i$-th vehicle, the increment of the classification loss after masking this block is defined as the discriminative gain:

$\alpha_{i, k}=\max \left(0, L_{\mathrm{cls}}\left(q_i^{(-k)}\right)-L_{\mathrm{cls}}\left(q_i\right)\right)$

where, $q_i^{(-k)}$ denotes the semantic coordinates after setting the $k$-th semantic block to the missing state, and $L_{\text {cls}}$ is the vehicle classification loss. If masking a semantic block causes the classification loss to increase significantly, it indicates that this block contributes highly to the discrimination of the current vehicle identity, and it should be transmitted with priority when the transmission budget is limited. This definition can be directly computed by one block masking experiment, and is kept consistent with the block priority in the subsequent progressive transmission.

To make the discriminative gain quickly available at the inference stage, a lightweight saliency prediction head $h_\phi$ is designed to perform feedforward estimation of the semantic block importance. This prediction head consists of two fully connected layers, takes the $L_2$-normalized appearance embedding $z_i$ as input, and outputs a $K$-dimensional importance vector:

$\hat{\alpha}_i=\operatorname{softmax}\left(h_\phi\left(z_i\right)\right) \in \Delta^{K-1}$

where, $\phi$ is the prediction head parameter, $\Delta^{K-1}$ denotes the $K$-dimensional probability simplex, and the components of $\hat{\alpha}_i$ correspond to the predicted discriminative gain of each semantic block. In the training stage, the increment of the classification loss after block masking is used as the supervision signal, so that $\hat{\alpha}_i$ approaches $\alpha_i$. The number of parameters of this prediction head is less than 0.1 M , and it is used only for training and inference at the edge, without increasing the burden on the cloud. At inference, the edge sorts the semantic blocks in descending order according to $\hat{\alpha}_i$ and generates a transmission priority queue, so that the limited uplink budget preferentially carries the semantic components that contribute most to vehicle identity discrimination.

Semantic block organization follows three principles: independently decodable, progressively fusable, and feedback queryable. Being independently decodable requires each semantic block to contain a complete quantization codeword and block index, so that the cloud can decode and perform preliminary classification without waiting for all the blocks. Progressive fusion is achieved by introducing masked reconstruction and a progressive classification loss in training, so that the combination of the first several blocks still maintains semantic consistency and avoids feature space misalignment caused by partial reception. Feedback queryability associates the block index with the spatial region, so that the cloud can request, through a downlink query vector, that the edge supplement a specific block or increase the bit width of a specific block. Finally, each vehicle generates a priority queue $\left\{\pi_i(1), \pi_i(2), \ldots, \pi_i(K)\right\}$ sorted in descending order of discriminative gain, where $\pi_i(1)$ is the semantic block with the highest discriminative gain. This queue is truncated for transmission when the link quality is poor, retaining only the first several high-gain blocks; it is transmitted in full when the link quality is good, so as to improve the vehicle re-identification accuracy. As a result, semantic block organization is no longer a static partitioning, but a transmission unit that is dynamically coupled with the link state and the cloud recognition requirement.

2.5 Link-state-aware progressive semantic transmission

NB-IoT link quality exhibits significant time variability and spatial nonuniformity, and a fixed compression ratio or a fixed feature dimension can hardly guarantee the availability of key vehicle semantics when the link degrades. To this end, the edge estimates the link state $Q_t=\left\{\mathrm{SNR}_t, \mathrm{RSRP}_t\right.$, retrans$\left._t, P_t\right\}$ in each transmission time slot, where $\mathrm{SNR}_t$ is the signal-to-noise ratio, $\mathrm{RSRP}_t$ is the reference signal received power, retrans$_t$ is the number of retransmissions, and $P_t$ is the available application-layer payload budget of the current time slot. The first two determine the bit error rate and the available modulation and coding scheme, the number of retransmissions reflects the historical congestion level, and the application-layer payload budget constrains the amount of data that the current time slot can carry. Based on this, the edge decides which semantic blocks to send and how many bits to use for each block. When the link quality is poor, only the first $m$ semantic blocks with the highest discriminative gain are sent, ensuring that key attributes such as vehicle category and color remain recognizable; when the link quality is good, the number of semantic blocks is increased or the quantization bit width is raised, so as to improve the vehicle re-identification accuracy. This strategy avoids the loss of key semantics caused by a fixed compression ratio when the link degrades, and at the same time prevents redundant bits from being wasted when the link is good.

Figure 3. Schematic diagram of link-state-aware water-filling bit allocation and progressive transmission mechanism

As shown in Figure 3, the water-filling bit allocation mechanism can dynamically switch strategies according to the real-time available budget: it performs truncated transmission to guarantee key features when the link quality is poor, and performs full transmission to improve the reidentification accuracy when the budget is sufficient. Given the available uplink budget $B_t$ of the current time slot and the set of blocks to be transmitted $\pi_t \subseteq\{1, \ldots, K\}$, progressive block selection can be formalized as an expected utility maximization problem:

$\pi_t^*=\underset{\pi_t}{\operatorname{argmax}} \mathrm{E}_y\left[U\left(y_i, \hat{y}_i\left(q_{i, \pi_t}\right)\right)\right]$, s.t. $\sum_{k \in \pi_t} b_k\left(Q_t\right) \leq B_t$

where, $K$ is the total number of semantic blocks, $q_{i, \pi_t}$ is the combination of semantic blocks corresponding to the set $\pi_t, \hat{y}_i$ is the vehicle recognition result obtained by the cloud based on the received semantic blocks, the utility $U$ can be the negative cross-entropy or the mutual information $I\left(y_i ; q_{i, \pi_t}\right)$, and $b_k\left(Q_t\right)$ is the number of bits occupied by the $k$-th semantic block under the current link state. Since $K=8$ and the number of blocks is small, a greedy strategy is adopted to select semantic blocks in descending order of $\alpha_{i, k} / b_k$ until the budget is exhausted, with a complexity of $O(K \log K)$, which is suitable for real-time operation at the edge. When multiple vehicles share the uplink budget, the number of blocks is further allocated according to the vehicle recognition uncertainty and the detection confidence, giving priority to high-confidence vehicles and high-risk vehicles, so that the limited bits are also allocated on demand among vehicle instances.

After the set of blocks to be transmitted is determined, the quantization bit width is adaptively adjusted with the link quality and the semantic block importance. Let $b_k$ denote the number of payload bits of the $k$-th semantic block, whose value ranges from $b_{\min }=32$ to $b_{\max }=128$ bit, corresponding to 4 to 16 bit quantization per dimension. Given the discriminative gain $\alpha_{i, k}$, water-filling bit allocation is adopted:

$b_k=\operatorname{clip}\left(\operatorname{round}\left(b_{\min}+\left(B_{t^{-}}\left|\pi_t\right| b_{\min}\right) \frac{\alpha_{i, k}}{\sum_{j \in \pi_t} \alpha_{i, j}}\right), b_{\min}, b_{\max }\right)$

where, $b_{\min}$ and $b_{\max }$ are the minimum and maximum quantization bit widths of a semantic block, respectively, round( ) is the rounding operation, clip() limits the result to the range $\left[b_{\text {min}}, b_{\text {max}}\right], \alpha_{i, k}$ is the discriminative gain of the $k$-th semantic block, and $\sum_{j \in \pi_t} \alpha_{i, j}$ is the total discriminative gain of the current set of blocks to be transmitted. Blocks with high discriminative gain obtain more bits, while blocks with low gain use the lowest bit width. This allocation can be regarded as an approximate solution to maximizing the semantic discriminative gain under the total bit constraint. When the link is poor, $B_t$ is small, and the bit width is concentrated on the first $m$ high-gain blocks; when the link is good, $B_t$ is large, and more semantic blocks obtain a medium bit width. Compared with a uniform bit width, water-filling allocation improves the recognition accuracy of the first few semantic blocks under the same budget, making the early results of progressive transmission more usable.

After receiving part of the semantic blocks, the cloud adopts a masked progressive classifier to update the vehicle recognition posterior:

$\hat{p}_i^{(m)}=\operatorname{softmax}\left(W_c\left[\tilde{q}_{i, \pi_t} ; M_{\pi_t} ; s_i\right]+b_c\right)$

where, $\tilde{q}_{i, \pi_t}$ is the concatenation of the received semantic blocks, $M_{\pi_t}$ is the block mask used to indicate the missing semantic blocks, $s_i$ is the scene context embedding, and $W_c$ and $b_c$ are the classifier weight and bias. The mask vector and the indices of the received blocks are jointly input, so that the classifier can distinguish a zero value from an unreceived state, and avoid missing blocks being misjudged as valid zero values. As more semantic blocks arrive, the cloud posterior is progressively refined, and the current recognition uncertainty is computed:

$H_i^{(m)}=-\sum_{c=1}^C \hat{p}_{i, c}^{(m)} \log \hat{p}_{i, c}^{(m)}$

where, $C$ is the number of vehicle categories, $\hat{p}_{i, c}^{(m)}$ is the predicted probability of the $c$-th category, and $H_i^{(m)}$ is the current posterior entropy. If $H_i^{(m)}$ is lower than the preset threshold, the transmission of this vehicle is terminated early to save the uplink budget; if $H_i^{(m)}$ remains high, the subsequent feedback refinement is triggered. This mechanism makes the transmission policy itself a controllable variable of the vehicle recognition accuracy rather than a fixed preprocessing step, and provides an explicit triggering basis for edge-cloud feedback refinement.

2.6 Dynamic refinement driven by edge–cloud semantic feedback

After the cloud completes progressive classification, in addition to outputting the vehicle category and re-identification result, it also needs to evaluate whether the current recognition state is reliable, so as to decide whether to request the edge to supplement semantics. The classification uncertainty is measured by the current posterior entropy $H_i^{(m)}$, whose computation is consistent with that in Section 2.5. The gallery-matching ambiguity is defined as:

$A_i=1-\max _j \operatorname{sim}\left(q_i^{(m)}, r_j\right)$

where, $q_i^{(m)}$ is the currently received semantic coordinates, $r_j$ is the vehicle gallery prototype, and sim is the cosine similarity. If $A_i$ is high, it indicates that the current semantic coordinates are similar to multiple known vehicles and it is difficult to uniquely determine the identity. Feedback is triggered when $H_i^{(m)}>\tau_H$, or $A_i>\tau_A$, or $\max _c \hat{p}_{i, c}^{(m)}<\tau_p$, where $\tau_H, \tau_A$, and $\tau_p$ control the category uncertainty, the gallery ambiguity, and the maximum category confidence, respectively. A lower threshold triggers more refinement, which improves the recognition accuracy but increases the uplink bytes; a higher threshold saves the transmission budget but reduces the recall rate of difficult samples.

If feedback is triggered, the cloud sends a compact query vector through the NB-IoT downlink:

$u_i=\operatorname{MLP}\left(\left[H_i^{(m)}, A_i, \hat{p}_i^{(m)}, \tilde{b}_i\right]\right) \in \mathrm{R}^r, r \ll d$

where, $\hat{p}_i^{(m)}$ is the current category posterior, $\tilde{b}_i$ is the normalized position and scale, $r$ is the dimension of the query vector, which is usually taken as 16 or 32 , and $d$ is the dimension of the semantic coordinates. This query vector occupies only a small number of downlink bits, yet contains four types of information: the current uncertainty, the gallery ambiguity, the category posterior, and the spatial position. Based on this, the edge determines which region of the vehicle should be focused on, which semantic blocks need a higher bit width, and whether the region of interest needs to be re-cropped. Compared with the scheme without feedback, this downlink query enables the cloud recognition state to reversely affect the edge encoding behavior, so that the uplink semantic supplement has an explicit direction.

Figure 4. Flowchart of edge dynamic refinement based on downlink compact query and Feature-wise Linear Modulation (FiLM)

The specific secondary query and feature enhancement mechanism is shown in Figure 4. With the Feature-wise Linear Modulation (FiLM) module, the edge uses the downlink query vector to dynamically enhance specific channels in the original high-resolution image, thereby extracting the most complementary local semantics. After receiving $u_i$, the edge performs high-resolution cropping of the corresponding region of interest in the original frame, and modulates the appearance encoder in a FiLM manner:

$\begin{gathered}\gamma_{i^{\prime}} \beta_i=\operatorname{MLP}\left(u_i\right), h_i^{+}=\gamma_i \odot h_i+\beta_i \\ z_i^{+}=E_{a p p}^{+}\left(\operatorname{ROLAlign}\left(F_{h r}, b_i\right) ; u_i\right), \Delta q_i=Q\left(z_i^{+}\right)\end{gathered}$

where, $F_{h r}$ is the high-resolution feature, $E_{\text {app}}^{+}$is the refinement encoder with query modulation, $\gamma_i$ and $\beta_i$ are the FiLM modulation parameters, ⊙ denotes element-wise multiplication, $h_i$ and $h_i^{+}$are the features before and after modulation, respectively, and $\Delta q_i$ is the supplementary semantics. FiLM modulation enables the edge to dynamically enhance specific channels according to the cloud query. When the ambiguity mainly comes from color difference, color-related channels are enhanced; when the ambiguity mainly comes from vehicle type difference, contour- and grille-related channels are enhanced. The supplementary semantics usually contain only 2 to 4 high-priority blocks, avoiding occupying too much uplink budget again.

The cloud fuses the supplementary semantics $\Delta q_i$ with the existing semantics $q_i^{(m)}$ to update the vehicle recognition posterior:

$\hat{p}_i^{\text {new }}=\operatorname{softmax}\left(W_c\left[q_i^{(m)} ; \Delta q_i ; s_i\right]+b_c\right)$,

where, $s_i$ is the scene context embedding, and $W_c$ and $b_c$ are the classifier weight and bias. Under the constraint of the total uplink budget $B_{\text {total }}$, the refinement resources are allocated according to the marginal utility:

$\max _{\mathrm{S},\left\{b_i\right\}} \sum_{i \in \mathrm{~S}} \Delta U_i\left(b_i\right)$,s.t. $\sum_{i \in \mathrm{~S}} b_i \leq B_{\text {total }}$

where, $S$ is the set of vehicles to be refined, $b_i$ is the supplementary bits allocated to the $i$-th vehicle, and $\Delta U_i\left(b_i\right) \approx H_i^{(m)}-H_i^{(m)}\left(b_i\right)$ denotes the uncertainty reduction brought by the additional bits. Lagrangian optimality gives:

$b_i^*=\underset{b}{\operatorname{argmax}}\left[\Delta U_i(b)-\lambda b\right]$

where, $\lambda$ is the Lagrange multiplier used to balance the recognition gain and the bit cost. This allocation gives priority to refining vehicle instances that are highly uncertain, visually ambiguous, and contribute the most to the global recognition gain, so that the limited uplink budget is concentrated on the difficult samples that truly need supplementary semantics. Through this feedback loop, the cloud guides the quality of the uplink semantics at the edge through an extremely narrowband downlink control channel, achieving on-demand refinement and the dynamic closure of semantic transmission.

2.7 Unified training and inference

Unified training incorporates the dual-branch semantic encoder, the quantizer, the saliency prediction head, the cloud-side masked progressive classifier, and the feedback refinement module into the same optimization process. The training is divided into two stages. In the first stage, the lightweight detector is fixed, and the encoder, the quantizer, and the classifier are optimized. The total loss is written as:

$L=L_{c l s}+\lambda_1 L_{r e i d}+\lambda_2 L_{q u a n t}+\lambda_3 L_{c t x}+\lambda_4 R(B)+\lambda_5 L_{f b}$

where, $L_{\text {cls}}$ is the vehicle classification loss, $L_{\text {reid}}$ is the vehicle reidentification loss, $L_{\text {quant}}$ is the quantization reconstruction and entropy regularization loss, $L_{\text {ctx}}$ is the context consistency loss, $R(B)$ is the transmission bit cost, $L_{f b}$ is the feedback refinement loss, and $\lambda_1$ to $\lambda_5$ are the weights of the respective losses. In the second stage, the saliency prediction head and the feedback refinement module are added, and joint fine-tuning is performed with the block masking, progressive classification, and feedback fusion losses, so that the classifier adapts to partial semantic input. During training, part of the semantic blocks are randomly dropped and the quantization bit width is randomly set, so as to simulate NB-IoT link fluctuation. The optimizer adopts Adam with Decoupled Weight Decay (AdamW), with an initial learning rate of $1 \times 10^{-3}$, a batch size of 64, a semantic dimension $d=64$, and the number of semantic blocks $K=8$. The loss weights $\lambda_1$ to $\lambda_5$ are determined by grid search on the validation set.

The inference stage is executed in the order of edge encoding, linkadaptive transmission, cloud-side progressive recognition, and feedback refinement. The edge detects vehicles and extracts ROIs; the dual-branch encoder outputs the semantic coordinates $q_i$ and the context embedding $s_i$; the saliency prediction head outputs $\hat{\alpha}_i$ and generates the semantic block priority queue. According to the link state $Q_t$ and the available budget $B_t$, the edge selects the set of blocks to be transmitted, allocates the quantization bit width, and sends the semantic coordinates according to the priority. After receiving part of the semantic blocks, the cloud performs masked progressive classification and computes the classification uncertainty $H_i^{(m)}$ and the gallery-matching ambiguity $A_i$. If the triggering condition is satisfied, the cloud sends the compact query vector $u_i$ through the downlink; based on this, the edge performs high-resolution re-encoding of the specified ROI and sends back the supplementary semantics $\Delta q_i$, and the cloud updates the recognition result after fusion. The whole pipeline can be terminated early when the budget is exhausted or the uncertainty is lower than the threshold. The computation of a single frame at the edge is controlled within 1.5 Giga Floating-Point Operations (GFLOPs), the number of parameters is less than 5M, the complexity of semantic block ranking and bit width allocation is $O(K \log K)$, and the cloud only processes the 64-dimensional semantic coordinates and a lightweight classifier. The semantic coordinates of a single vehicle are about 128 bytes, which satisfies NB-IoT single-packet or few-packet transmission, and progressive transmission and early termination keep the satisfaction rate of the prescribed transmission budget at 100%.