跨视角地理定位中的孪生网络与注意力机制，孪生网络+注意力机制：跨视角地理定位如何让AI学会“认路识图”

目录

一、问题本质：跨视角图像匹配为什么这么难？

二、技术基石：孪生网络如何“学会比较”

三、注意力机制：让模型学会“哪里值得看”

3.1 空间注意力：找到图像中的关键位置

3.2 交叉注意力：建立跨视角的特征对应

3.3 结合孪生网络与交叉注意力的完整架构

四、最新进展：Transformer如何重塑这个领域

4.1 从CNN到Vision Transformer

4.2 多尺度注意力与金字塔结构

五、实战：完整的训练代码

5.1 数据集准备

5.2 损失函数的选择

5.3 完整训练循环

5.4 推理代码：给定一张图像，检索最相似的位置

一、问题本质：跨视角图像匹配为什么这么难？

我们先来拆解一下这个问题的难度。

假设你有一张查询图像（比如手机拍的街景），和一个待匹配的候选集（比如某区域的卫星图库）。任务很简单：找到候选集中对应同一地点的卫星图。

表面上看，这是一个图像检索问题。但难点在于：

1. 视角变换剧烈：地面视角和鸟瞰视角的几何畸变是非线性的，简单的仿射变换无法对齐

2. 尺度差异巨大：卫星图覆盖数百米范围，街景图只看到几十米内的局部

3. 遮挡与缺失：街景中的树木、建筑会遮挡背景，而卫星图看不到这些细节

4. 动态元素干扰：车辆、行人、光影变化在不同时间采集的图像中完全不同

传统的SIFT、ORB等特征匹配方法在这些场景下基本失效。深度学习兴起后，人们开始训练卷积神经网络将不同视角的图像映射到同一个“特征空间”，让同一地点的两张图在特征空间中靠近，不同地点的远离。

这就是孪生网络的基本思路——两个共享权重的分支分别提取查询图和候选图的特征，然后计算特征相似度。

但早期的方法有个致命问题：它们试图把整张图压缩成一个全局特征向量。街道的招牌、路口的树木、斑马线的纹理……所有这些细节被揉成一团，关键信息淹没在无关的噪声里。

直到注意力机制加入战场，事情才有了质的改变。

二、技术基石：孪生网络如何“学会比较”

先花点时间把孪生网络讲透。

孪生网络（Siamese Network）的名字来源于“孪生”——双胞胎。它的结构很简单：两个结构完全相同、共享参数的神经网络（通常称为“双塔”），分别处理两张输入图像，输出两个特征向量，然后通过一个距离度量函数计算相似度。

训练时的目标很明确：

• 正样本对（同一地点的两张不同视角图像）的距离尽可能小

• 负样本对（不同地点的图像）的距离尽可能大

损失函数通常用对比损失（Contrastive Loss）或三元组损失（Triplet Loss）。

用PyTorch实现一个基础的孪生网络主干并不复杂：

python

import torch import torch.nn as nn import torch.nn.functional as F class SiameseBackbone(nn.Module): def __init__(self, embedding_dim=512): super().__init__() # 使用预训练的ResNet50作为基础特征提取器 from torchvision.models import resnet50, ResNet50_Weights base = resnet50(weights=ResNet50_Weights.IMAGENET1K_V1) # 去掉原来的全连接层，保持卷积部分 self.features = nn.Sequential(*list(base.children())[:-2]) # 全局平均池化 + 降维到embedding维度 self.gap = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(2048, embedding_dim) # BN + ReLU对embedding做归一化前的处理 self.bn = nn.BatchNorm1d(embedding_dim) def forward(self, x): # x: (B, 3, H, W) features = self.features(x) # (B, 2048, H/32, W/32) pooled = self.gap(features) # (B, 2048, 1, 1) pooled = pooled.view(pooled.size(0), -1) # (B, 2048) embedding = self.fc(pooled) # (B, embedding_dim) embedding = self.bn(embedding) # L2归一化，后续直接用点积计算相似度 embedding = F.normalize(embedding, p=2, dim=1) return embedding class SiameseNetwork(nn.Module): def __init__(self, embedding_dim=512): super().__init__() self.encoder = SiameseBackbone(embedding_dim) def forward(self, img1, img2): # 两个分支共享同一个encoder emb1 = self.encoder(img1) emb2 = self.encoder(img2) # 计算余弦相似度（点积，因为已经L2归一化） similarity = (emb1 * emb2).sum(dim=1) return similarity, emb1, emb2

这个基础架构能工作，但准确率远不够实用。为什么？因为当输入图像非常复杂时，全局池化丢失了太多空间信息。卫星图中心是一片空地，四周是道路网络；街景图里有一排特色商铺。这两个特征原本可以通过空间对应关系关联起来，但全局池化把空间位置信息全部抹平了。

这时候就需要注意力机制登场了。

三、注意力机制：让模型学会“哪里值得看”

注意力机制的核心思想非常直观：在处理信息时，不要给所有位置同样的权重，而是动态地聚焦在最重要的部分。

对于跨视角定位来说，这意味着：

• 街景图中的天空、路面、车辆尾部这些信息，对于匹配卫星图几乎没有帮助

• 而独特的建筑轮廓、路口结构、标志牌位置，才是关键线索

• 不同图像中，“关键区域”的位置完全不同——不能用手工设计的固定区域

注意力机制可以自动学习到哪里是“值得注意”的。

3.1 空间注意力：找到图像中的关键位置

空间注意力会生成一个与特征图尺寸相同的权重图，告诉模型“这个位置重要，那个位置不重要”。

python

class SpatialAttention(nn.Module): """空间注意力模块：生成2D注意力权重图""" def __init__(self, in_channels, reduction=16): super().__init__() self.conv1 = nn.Conv2d(in_channels, in_channels // reduction, 1) self.conv2 = nn.Conv2d(in_channels // reduction, 1, 1) self.relu = nn.ReLU(inplace=True) self.sigmoid = nn.Sigmoid() def forward(self, x): # x: (B, C, H, W) attn = self.relu(self.conv1(x)) attn = self.conv2(attn) # (B, 1, H, W) attn = self.sigmoid(attn) return x * attn

但单图的空间注意力还不够——它只能看到一张图内部的显著性，无法建立两张图之间的对应关系。

3.2 交叉注意力：建立跨视角的特征对应

这才是真正的“杀手锏”。交叉注意力让两张图在特征空间中“互相看”：街景图的某个局部区域，应该去关注卫星图的哪些对应区域？

这个想法很接近人类做跨视角匹配时的策略——你会在街景里找一个独特的建筑，然后在卫星图里扫描类似形状的阴影或屋顶。

python

class CrossAttentionLayer(nn.Module): """跨视角交叉注意力模块""" def __init__(self, embed_dim, num_heads=8): super().__init__() self.num_heads = num_heads self.embed_dim = embed_dim self.head_dim = embed_dim // num_heads self.q_proj = nn.Linear(embed_dim, embed_dim) self.k_proj = nn.Linear(embed_dim, embed_dim) self.v_proj = nn.Linear(embed_dim, embed_dim) self.out_proj = nn.Linear(embed_dim, embed_dim) self.scale = self.head_dim ** -0.5 def forward(self, query_feat, key_feat, value_feat): """ query_feat: 来自查询图像的特征 (B, N, C) key_feat, value_feat: 来自参考图像的特征 (B, M, C) """ B, N, C = query_feat.shape _, M, _ = key_feat.shape # 投影 Q = self.q_proj(query_feat).view(B, N, self.num_heads, self.head_dim).transpose(1, 2) K = self.k_proj(key_feat).view(B, M, self.num_heads, self.head_dim).transpose(1, 2) V = self.v_proj(value_feat).view(B, M, self.num_heads, self.head_dim).transpose(1, 2) # 注意力权重 attn = torch.matmul(Q, K.transpose(-2, -1)) * self.scale attn = F.softmax(attn, dim=-1) # 加权求和 out = torch.matmul(attn, V) # (B, n_heads, N, head_dim) out = out.transpose(1, 2).contiguous().view(B, N, C) out = self.out_proj(out) return out

有了交叉注意力，两个视图的特征可以“对齐”了。街景中看到一个红色屋顶，模型会在卫星图中寻找同样颜色和形状的屋顶区域，即使它们在整图中的位置和旋转角度不同。

3.3 结合孪生网络与交叉注意力的完整架构

把两部分组装起来，形成一个端到端的可训练模型：

python

class SiameseWithCrossAttention(nn.Module): def __init__(self, backbone='resnet50', embed_dim=512): super().__init__() # 共享的卷积主干，输出降低空间分辨率的高维特征 from torchvision.models import resnet50 resnet = resnet50(weights=ResNet50_Weights.IMAGENET1K_V1) self.backbone = nn.Sequential(*list(resnet.children())[:-2]) # 降维卷积，将2048通道降到embed_dim self.reduce_conv = nn.Conv2d(2048, embed_dim, 1) # 交叉注意力层（使用 Transformer 编码器风格） self.cross_attn = CrossAttentionLayer(embed_dim, num_heads=8) # 自注意力层（可选，用于内部特征聚合） self.self_attn = nn.MultiheadAttention(embed_dim, num_heads=8, batch_first=True) # 最终特征聚合和降维 self.global_pool = nn.AdaptiveAvgPool2d(1) self.projection = nn.Sequential( nn.Linear(embed_dim, embed_dim), nn.BatchNorm1d(embed_dim), nn.ReLU(), nn.Linear(embed_dim, embed_dim) ) def forward(self, query_img, reference_img): # 1. 共享主干提取特征 query_feat = self.backbone(query_img) # (B, 2048, H, W) ref_feat = self.backbone(reference_img) # 2. 降维 query_feat = self.reduce_conv(query_feat) # (B, C, H, W) ref_feat = self.reduce_conv(ref_feat) B, C, H, W = query_feat.shape # 3. 展平为序列 (B, H*W, C) query_seq = query_feat.flatten(2).transpose(1, 2) ref_seq = ref_feat.flatten(2).transpose(1, 2) # 4. 交叉注意力：query attend to reference cross_features = self.cross_attn(query_seq, ref_seq, ref_seq) # 5. 自注意力进一步聚合（可选） attended, _ = self.self_attn(cross_features, cross_features, cross_features) # 6. 加回残差连接，保留原始query信息 combined = query_seq + attended # 7. 重塑回2D特征图，全局池化 combined_2d = combined.transpose(1, 2).view(B, C, H, W) pooled = self.global_pool(combined_2d).squeeze(-1).squeeze(-1) # (B, C) # 8. 最终投影并归一化 embedding = self.projection(pooled) embedding = F.normalize(embedding, p=2, dim=1) return embedding

这个结构的关键创新在于特征不对齐之前先“交流”——不是简单地把两个视图的特征图拼在一起或分别池化，而是让它们通过交叉注意力机制互相补充信息。

四、最新进展：Transformer如何重塑这个领域

2023年到2024年，跨视角地理定位领域有两个重要的技术转向。

4.1 从CNN到Vision Transformer

CNN的局部感受野天然限制了远距离特征交互。而ViT（Vision Transformer）的自注意力机制可以在一开始就建立全局关联。

2023年发表在CVPR的TransGeo工作证明了：一个纯粹的Transformer架构，配合精心设计的注意力掩码，可以在跨视角定位中大幅超越CNN方案。它的核心洞察是：卫星图和街景图之间的对应关系往往是非局部的——街景左边的一栋楼，可能在卫星图的右上角。

下面是用ViT实现跨视角特征提取的简化版本：

python

import torch from torch import nn from einops import rearrange class CrossViewViT(nn.Module): def __init__(self, image_size=224, patch_size=16, dim=512, depth=6, heads=8): super().__init__() # 分块嵌入 self.patch_embed = nn.Conv2d(3, dim, kernel_size=patch_size, stride=patch_size) num_patches = (image_size // patch_size) ** 2 # 位置编码 self.pos_embed = nn.Parameter(torch.randn(1, num_patches, dim)) # Transformer编码器（共享） encoder_layer = nn.TransformerEncoderLayer( d_model=dim, nhead=heads, dim_feedforward=dim*4, batch_first=True, dropout=0.1 ) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=depth) # 跨视角融合模块 self.cross_attn = nn.MultiheadAttention(dim, heads, batch_first=True) def forward(self, query, reference): # 提取patch序列 q_patches = self.patch_embed(query).flatten(2).transpose(1, 2) r_patches = self.patch_embed(reference).flatten(2).transpose(1, 2) # 加位置编码 q_patches = q_patches + self.pos_embed r_patches = r_patches + self.pos_embed # 各自通过Transformer编码器 q_feat = self.transformer(q_patches) r_feat = self.transformer(r_patches) # 交叉注意力——让query特征去关注reference中最相关的patches cross_feat, attn_weights = self.cross_attn(q_feat, r_feat, r_feat) # 聚合为全局特征 q_global = cross_feat.mean(dim=1) r_global = r_feat.mean(dim=1) return F.normalize(q_global, dim=-1), F.normalize(r_global, dim=-1)

ViT的优势很明显：特征图中的每个patch都能直接“看到”所有其他patch，这对于建立跨视角的远距离对应非常重要。比如，街景中的天际线轮廓，需要和卫星图中零散分布的高层建筑群匹配——ViT的自注意力机制可以轻松捕捉这种跨区域的模式。

4.2 多尺度注意力与金字塔结构

另一个重要进展是多尺度特征对齐。同一个地点，从地平面看过去，近处的商店招牌可能在画面中占据很大面积，远处的摩天大楼反而很小。但在卫星图里，它们的大小比例完全不同。

解决这个问题需要模型同时在不同空间尺度上建立对应。2024年初提出的Pyramid Cross-Attention架构，通过构建特征金字塔，让模型在粗尺度上匹配整体布局，在细尺度上匹配局部纹理。

python

class PyramidCrossAttention(nn.Module): def __init__(self, in_channels=2048, num_levels=3): super().__init__() self.num_levels = num_levels # 不同尺度的降维和注意力模块 self.reduce_conv = nn.ModuleList() self.cross_attns = nn.ModuleList() for i in range(num_levels): # 降维到不同维度 out_dim = 512 // (2 ** i) if i < 2 else 128 self.reduce_conv.append(nn.Conv2d(in_channels, out_dim, 1)) # 交叉注意力 self.cross_attns.append( CrossAttentionLayer(out_dim, num_heads=max(4, 8//(i+1))) ) # 融合多尺度特征 self.fusion = nn.Sequential( nn.Linear(512 + 256 + 128, 512), nn.ReLU(), nn.Linear(512, 512) ) def forward(self, query_feats, ref_feats): """ query_feats, ref_feats: 多层特征图列表，来自FPN或类似结构 """ multi_scale_embeds = [] for i in range(self.num_levels): q_feat = query_feats[i] # (B, C, H_i, W_i) r_feat = ref_feats[i] # 降维 q_feat = self.reduce_conv[i](q_feat) r_feat = self.reduce_conv[i](r_feat) B, C, H, W = q_feat.shape # 展开序列 q_seq = q_feat.flatten(2).transpose(1, 2) r_seq = r_feat.flatten(2).transpose(1, 2) # 交叉注意力 cross_out = self.cross_attns[i](q_seq, r_seq, r_seq) # 全局池化 global_feat = cross_out.mean(dim=1) # (B, C) multi_scale_embeds.append(global_feat) # 拼接不同尺度特征 concat_feat = torch.cat(multi_scale_embeds, dim=1) final_embed = self.fusion(concat_feat) return F.normalize(final_embed, dim=1)

这种金字塔结构的实际效果非常显著：在城市级定位任务中，top-1准确率比单尺度方案提升了8-12个百分点。

五、实战：完整的训练代码

说了这么多理论，我们来搭建一个可以真正训练的模型。这里以CVUSA数据集（包含街景-卫星图对）为例，实现一个完整的训练流程。

5.1 数据集准备

python

import os from torch.utils.data import Dataset, DataLoader from PIL import Image import torchvision.transforms as transforms class CrossViewDataset(Dataset): def __init__(self, root_dir, split='train', img_size=224): self.root_dir = root_dir self.split = split self.img_size = img_size # 读取图像对列表 # 假设数据集结构: root/satellite/xxx.jpg, root/street/xxx.jpg, pairs.txt with open(os.path.join(root_dir, f'{split}_pairs.txt'), 'r') as f: self.pairs = [line.strip().split() for line in f.readlines()] # 数据增强：训练集使用更强的变换 if split == 'train': self.sat_transform = transforms.Compose([ transforms.Resize((img_size, img_size)), transforms.RandomRotation(20), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.2, contrast=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) self.street_transform = transforms.Compose([ transforms.Resize((img_size, img_size)), transforms.RandomCrop(img_size), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) else: self.sat_transform = transforms.Compose([ transforms.Resize((img_size, img_size)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) self.street_transform = self.sat_transform def __len__(self): return len(self.pairs) def __getitem__(self, idx): sat_path, street_path = self.pairs[idx] sat_img = Image.open(os.path.join(self.root_dir, sat_path)).convert('RGB') street_img = Image.open(os.path.join(self.root_dir, street_path)).convert('RGB') sat_tensor = self.sat_transform(sat_img) street_tensor = self.street_transform(street_img) return sat_tensor, street_tensor, idx

5.2 损失函数的选择

跨视角定位中，最常用的损失函数是三元组损失（Triplet Loss）和InfoNCE。我们这里实现一个加权的变体——Circle Loss，它对不同难度的样本自动调整梯度权重。

python

class CircleLoss(nn.Module): """ Circle Loss for cross-view geo-localization 论文: Circle Loss: A Unified Perspective of Pair Similarity Optimization """ def __init__(self, margin=0.25, gamma=64): super().__init__() self.margin = margin self.gamma = gamma def forward(self, query_emb, gallery_emb, labels): """ query_emb: (B, D) 查询图像特征 gallery_emb: (B, D) 候选图像特征（正样本配对） labels: (B,) 仅用于调试，实际使用正样本index """ # 计算相似度矩阵 sim = torch.matmul(query_emb, gallery_emb.t()) # (B, B) # 对角线是正样本对 pos_sim = sim.diag().view(-1, 1) # (B, 1) neg_sim = sim - torch.eye(sim.size(0)).to(sim.device) * 1e8 # 屏蔽正样本 # Circle Loss 公式 delta_p = 1 - self.margin delta_n = self.margin logit_p = -self.gamma * torch.relu(delta_p - pos_sim.detach()) * (pos_sim - delta_p) # 对每个anchor，取最难的负样本（相似度最高） max_neg_sim, _ = neg_sim.max(dim=1) logit_n = self.gamma * torch.relu(max_neg_sim - delta_n) * (max_neg_sim - delta_n) loss = torch.log(1 + torch.exp(logit_n + logit_p)) return loss.mean()

5.3 完整训练循环

python

import torch.optim as optim from torch.cuda.amp import GradScaler, autocast from tqdm import tqdm def train_one_epoch(model, dataloader, optimizer, criterion, scaler, device): model.train() total_loss = 0 pbar = tqdm(dataloader, desc='Training') for batch_idx, (sat_imgs, street_imgs, _) in enumerate(pbar): sat_imgs = sat_imgs.to(device) street_imgs = street_imgs.to(device) optimizer.zero_grad() # 混合精度训练加速 with autocast(): # 前向传播 sat_emb = model(street_imgs, sat_imgs) # query=street, ref=sat # 也可以互换方向，增加对称性约束 street_emb = model(sat_imgs, street_imgs) # 计算损失 loss1 = criterion(sat_emb, street_emb, None) loss2 = criterion(street_emb, sat_emb, None) loss = (loss1 + loss2) / 2 # 反向传播 scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() total_loss += loss.item() pbar.set_postfix({'loss': loss.item()}) return total_loss / len(dataloader) def validate(model, dataloader, device, top_k=[1, 5, 10]): model.eval() # 存储所有特征和索引 all_street_embs = [] all_sat_embs = [] with torch.no_grad(): for sat_imgs, street_imgs, idxs in tqdm(dataloader, desc='Validation'): sat_imgs = sat_imgs.to(device) street_imgs = street_imgs.to(device) # 注意：验证时不使用交叉注意力ref，或者使用自注意力的简化版本 # 这里假设模型有一个提取embedding的方法 street_emb = model.extract_street_embedding(street_imgs) sat_emb = model.extract_sat_embedding(sat_imgs) all_street_embs.append(street_emb.cpu()) all_sat_embs.append(sat_emb.cpu()) all_street_embs = torch.cat(all_street_embs, dim=0) # (N, D) all_sat_embs = torch.cat(all_sat_embs, dim=0) # 计算相似度矩阵 sim_matrix = torch.matmul(all_street_embs, all_sat_embs.t()) # (N, N) # 计算召回率 recalls = {} for k in top_k: # 对于每个street query，找出top-k相似的satellite图像 _, top_k_indices = sim_matrix.topk(k, dim=1) # (N, k) # 正确的索引应该与query的索引相同（因为dataloader按顺序排列） correct = (top_k_indices == torch.arange(len(sim_matrix)).unsqueeze(1)).any(dim=1) recall = correct.float().mean().item() recalls[f'R@{k}'] = recall * 100 return recalls # 主训练函数 def main(): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f"Using device: {device}") # 数据集 train_dataset = CrossViewDataset('./CVUSA', split='train') val_dataset = CrossViewDataset('./CVUSA', split='val') train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=8, pin_memory=True) val_loader = DataLoader(val_dataset, batch_size=128, shuffle=False, num_workers=4, pin_memory=True) # 模型 model = SiameseWithCrossAttention(embed_dim=512).to(device) # 优化器和学习率调度 optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100) scaler = GradScaler() # 损失函数 criterion = CircleLoss(margin=0.25, gamma=64) best_recall = 0.0 for epoch in range(100): train_loss = train_one_epoch(model, train_loader, optimizer, criterion, scaler, device) scheduler.step() if (epoch + 1) % 5 == 0: recalls = validate(model, val_loader, device) print(f"Epoch {epoch+1}: Loss={train_loss:.4f}, R@1={recalls['R@1']:.2f}%, " f"R@5={recalls['R@5']:.2f}%, R@10={recalls['R@10']:.2f}%") if recalls['R@1'] > best_recall: best_recall = recalls['R@1'] torch.save(model.state_dict(), 'best_model.pth') print(f"Best R@1: {best_recall:.2f}%")

5.4 推理代码：给定一张图像，检索最相似的位置

python

class CrossViewRetrieval: def __init__(self, model_path, model, device): self.device = device self.model = model.to(device) self.model.load_state_dict(torch.load(model_path, map_location=device)) self.model.eval() # 预先计算的卫星图特征库 self.sat_gallery = None self.sat_indices = None def build_gallery(self, sat_loader): """构建卫星图特征库""" all_embs = [] all_indices = [] with torch.no_grad(): for sat_imgs, _, idxs in sat_loader: sat_imgs = sat_imgs.to(self.device) # 提取卫星图特征（ref分支） emb = self.model.extract_sat_embedding(sat_imgs) all_embs.append(emb.cpu()) all_indices.extend(idxs) self.sat_gallery = torch.cat(all_embs, dim=0) self.sat_indices = all_indices def query(self, street_image, top_k=10): """给定街景图，检索最相似的卫星图""" street_tensor = self.preprocess(street_image).to(self.device) with torch.no_grad(): street_emb = self.model.extract_street_embedding(street_tensor) similarity = torch.matmul(street_emb, self.sat_gallery.t()) # (1, N) top_scores, top_ids = similarity.topk(top_k, dim=1) results = [] for score, idx in zip(top_scores[0], top_ids[0]): results.append({ 'gallery_id': self.sat_indices[idx], 'similarity': score.item(), 'satellite_path': self.get_sat_path(self.sat_indices[idx]) }) return results