Deep Metric Learning深度度量学习原理与实战指南(技术解析)

Deep metric learning 深度度量学习 总结 最近的工作用是深度度量学习的改进,这里将DML进行一个总结。 根据个人的理解,开篇用一句话介绍一下度量学习: “不同于分类学习,度量学习是通过学习数据之间的相似性程度来获得一个更有意义或者说更具可分性的特征空间。” Traditional metric learning 核心目的: 1 通过一个optimal的距离度量来判断样本之间的相似性 2 减小相似样本之间的距离,增加不相似样本之间的距离 限制条件:往往利用的的是线性映射,导致很难解决实际问题中的non-linear问题。(当然大部分传统方法都会遇到这 阅读详情

1. 深度度量学习:让AI学会“看脸识人”的核心技术

大家好,我是老张,在AI和智能硬件这行摸爬滚打了十几年。今天想和大家聊聊一个听起来有点学术,但实际上非常“接地气”的技术——深度度量学习。你可能没听过这个名字,但你肯定用过它:手机刷脸解锁、电商平台的“以图搜图”、甚至短视频App给你推荐“可能认识的人”,背后都有它的影子。

简单来说,度量学习就是教AI如何“看人下菜碟”地计算距离。传统方法里,我们计算两张图片像不像,可能就是简单粗暴地算算像素的欧氏距离。但你想啊,两张不同光线、不同角度的人脸照片,像素值可能天差地别,可它们明明是同一个人!度量学习要解决的就是这个问题:学习一个“智能卷尺”。这个卷尺不是量物理长度,而是量“语义相似度”。它能把所有数据(比如人脸图片)映射到一个新的“特征空间”里。在这个神奇的空间里,同一个人的不同照片会紧紧挨在一起,而不同人的照片则会离得远远的。深度度量学习,就是用强大的深度神经网络来当这个“智能卷尺”的制造者。

为什么这项技术这么火?因为现实世界的数据太复杂了。我们处理的不再是规整的数字表格,而是图片、声音、视频这些“非结构化数据”。度量学习让机器能理解这些数据背后抽象的“相似”概念,这是实现更智能应用的关键。接下来,我就带你从原理到实战,亲手搭建一个度量学习模型,让你彻底搞懂它到底是怎么工作的。

2. 核心原理拆解:三大支柱缺一不可

要玩转深度度量学习,你得先理解它的三大核心组件:特征提取网络、采样策略和损失函数。这就像盖房子,特征网络是地基和建材,采样策略是施工蓝图,损失函数则是监理标准,三者配合才能盖出高楼大厦。

2.1 特征提取网络:从像素到“灵魂”的编码器

特征提取网络,通常是一个卷积神经网络,它的任务是把一张图片(比如224x224的像素矩阵)压缩转换成一个低维的、富含语义信息的向量,这个向量叫做嵌入。你可以把它想象成给每张图片生成一个独一无二的“身份证号码”或者“灵魂编码”。

这个网络的设计至关重要。早期大家直接用现成的分类网络(比如ResNet、MobileNet)的倒数第二层输出作为特征。但后来发现,专为分类设计的网络,其学到的特征可能并不最适合度量“相似度”。于是,一些针对性的设计出现了:

  • 全局池化替代全连接:去掉最后的全连接层,改用全局平均池化,这样得到的特征图对空间位置更不敏感,更适合表征整体。
  • 引入注意力机制:让网络学会“看重点”。比如在人脸识别中,眼睛、鼻子、嘴巴的区域比背景更重要,注意力机制可以增强这些关键区域的特征响应。
  • 特征归一化:这是至关重要的一步。我们通常会对最终输出的嵌入向量进行L2归一化,使其模长为1。这样做的好处是,向量之间的点积就直接等于余弦相似度,所有的比较都落在一个超球面上,优化起来更稳定。在代码里,这通常就是一行 F.normalize(features, p=2, dim=1)。

我个人的经验是,对于大多数入门和中级任务,用一个在ImageNet上预训练过的ResNet50,去掉最后的分类头,接上一个全局平均池化和一个L2归一化层,作为特征提取器,效果就已经非常不错了,而且收敛速度快。

2.2 采样策略:如何高效地“组队学习”

损失函数(尤其是基于样本对的)的计算,依赖于样本之间的组合关系。如果在一个批次里随机计算所有样本对,计算量是爆炸的(O(N²)),而且很多样本对提供的学习信号非常微弱(比如两个明显不相似的样本)。因此,我们需要聪明的采样策略,从批次中挖掘出信息量最大的那些样本对或样本元组。

常见的采样策略有:

  • 困难样本挖掘:这是最核心的思想。不再使用所有样本对,而是专注于那些让模型“犯难”的样本对。包括:
    • 困难正样本:属于同一类,但当前模型让它们的特征距离却比较远的样本对。我们需要拉近它们。
    • 困难负样本:属于不同类,但当前模型让它们的特征距离却比较近的样本对。我们需要推开它们。
  • 批次内采样:这是目前最主流、最实用的方法。我们就在当前训练批次内部动态地寻找困难样本。具体实现时,在计算出批次内所有样本的特征后,我们会计算一个距离矩阵,然后为每个样本(锚点)寻找距离最远的正样本(困难正样本)和距离最近的负样本(困难负样本)。

这里有个我踩过的坑:在训练初期,模型还很弱,它找出来的“困难样本”可能本身就是噪声或极端异常值。如果过早地引入强力的困难样本挖掘,可能会导致训练不稳定。我的建议是,可以采用一种渐进式的策略,比如在训练的前几个Epoch使用随机采样或较温和的采样,等模型对数据分布有初步学习后,再逐步加大困难样本挖掘的力度。

2.3 损失函数:度量学习的“指挥棒”

损失函数是告诉模型优化方向的终极指南。深度度量学习的损失函数主要分为两大类,理解它们的区别是入门的关键。

第一类:基于分类的损失(Proxy-Based) 这类方法把度量学习问题转换成一个特殊的分类问题。它引入了一组可学习的参数,称为代理向量,每个类别对应一个代理。模型的目标是让样本的特征向量尽可能地靠近其对应类别的代理向量,而远离其他类别的代理向量。

  • 经典算法:ArcFace、CosFace、SphereFace。它们都是在经典的Softmax损失上做文章,在角度空间或余弦空间里加入一个间隔,使得类内更紧凑、类间更分离。
  • 优点:训练稳定、收敛快,特别适合类别数非常多(如百万级人脸ID)的场景,因为计算复杂度与类别数线性相关,而不是样本数的平方。
  • 缺点:需要明确的类别标签。如果数据只有相似/不相似的配对标签,而没有明确的类别ID,这类方法就无法直接使用。

第二类:基于样本对的损失(Pair-Based) 这类方法直接操作样本对或样本三元组。它不依赖代理,直接拉近正样本对的距离,推开负样本对的距离。

  • 经典算法:三元组损失、对比损失、N-pair损失、Multi-Similarity损失。
  • 三元组损失是最直观的:它需要一个锚点样本、一个正样本(与锚点同类)、一个负样本(与锚点不同类)。损失函数要求锚点到正样本的距离加上一个间隔后,仍然小于锚点到负样本的距离。
  • 优点:更加灵活,可以直接利用配对标签,概念非常直观。
  • 缺点:对采样策略极度敏感,训练可能不稳定,计算开销相对较大。

近年来,像 Circle Loss 这样的工作试图统一这两种范式。它提出了一个更通用的优化视角:将正相似度和负相似度分别推向一个目标值。这个框架非常优雅,让我对损失函数的设计有了新的认识。在实际项目中,我通常会先尝试ArcFace(如果有类别标签),因为它通常能提供一个很强的基线;如果效果不佳或数据形式受限,再考虑更复杂的基于样本对的损失,并精心设计采样策略。

3. 实战指南:用PaddlePaddle实现一个人脸对比模型

光说不练假把式。下面,我就带大家用PaddlePaddle框架,一步步实现一个基于三元组损失的人脸相似度对比模型。我们假设任务是这样的:给定两张人脸图片,判断它们是否属于同一个人。

3.1 环境准备与数据加载

首先,确保你的环境已经安装好PaddlePaddle。建议使用GPU版本以获得更快的训练速度。

pip install paddlepaddle-gpu

我们使用一个简化的人脸数据集,假设数据集目录结构如下,每个人一个文件夹,文件夹内是该人的多张照片:

dataset/
├── person_001/
│   ├── 001_001.jpg
│   └── 001_002.jpg
├── person_002/
│   ├── 002_001.jpg
│   └── 002_002.jpg
└── ...

数据加载的关键在于生成三元组。我们需要写一个数据生成器,每次提供一个(锚点,正样本,负样本)的图片三元组。

import os
import random
import paddle
from paddle.vision import transforms
from PIL import Image

class FaceTripletDataset(paddle.io.Dataset):
    def __init__(self, data_root, transform=None):
        self.data_root = data_root
        self.transform = transform
        self.classes = os.listdir(data_root)  # 每个人是一个类别
        self.class_to_images = {}
        
        # 建立类别到图片路径的映射
        for cls in self.classes:
            cls_path = os.path.join(data_root, cls)
            self.class_to_images[cls] = [os.path.join(cls_path, img) for img in os.listdir(cls_path)]
        
        # 生成所有可能的锚点-正样本对
        self.anchor_pos_pairs = []
        for cls, img_list in self.class_to_images.items():
            for i in range(len(img_list)):
                for j in range(i+1, len(img_list)):
                    self.anchor_pos_pairs.append((img_list[i], img_list[j], cls))
    
    def __getitem__(self, idx):
        # 先随机选择一个锚点-正样本对
        anchor_path, pos_path, pos_cls = self.anchor_pos_pairs[idx]
        
        # 随机选择一个不同的类别作为负样本类别
        neg_cls = random.choice([cls for cls in self.classes if cls != pos_cls])
        neg_path = random.choice(self.class_to_images[neg_cls])
        
        # 加载图片
        anchor_img = Image.open(anchor_path).convert('RGB')
        pos_img = Image.open(pos_path).convert('RGB')
        neg_img = Image.open(neg_path).convert('RGB')
        
        # 应用数据增强
        if self.transform:
            anchor_img = self.transform(anchor_img)
            pos_img = self.transform(pos_img)
            neg_img = self.transform(neg_img)
        
        return anchor_img, pos_img, neg_img
    
    def __len__(self):
        return len(self.anchor_pos_pairs)

# 定义数据预处理
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.RandomHorizontalFlip(),  # 简单的增强
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

# 创建数据集和数据加载器
dataset = FaceTripletDataset('path/to/your/dataset', transform=transform)
dataloader = paddle.io.DataLoader(dataset, batch_size=32, shuffle=True)

3.2 构建特征提取网络

我们将使用一个预训练的ResNet50作为骨干网络,并对其进行改造,使其输出一个归一化的特征向量。

import paddle
import paddle.nn as nn
import paddle.nn.functional as F

class EmbeddingNet(nn.Layer):
    def __init__(self, embedding_dim=128):
        super(EmbeddingNet, self).__init__()
        # 加载预训练的ResNet50,去掉最后的全连接层和平均池化层
        backbone = paddle.vision.models.resnet50(pretrained=True)
        modules = list(backbone.children())[:-2]  # 去掉最后的全局池化和全连接层
        self.feature_extractor = nn.Sequential(*modules)
        
        # 添加自定义的全局池化和投影头
        self.global_pool = nn.AdaptiveAvgPool2D((1, 1))
        # 将ResNet50的2048维特征映射到我们想要的embedding维度
        self.projection = nn.Linear(2048, embedding_dim)
        
    def forward(self, x):
        # 提取特征
        x = self.feature_extractor(x)  # 输出形状: [batch, 2048, 7, 7]
        x = self.global_pool(x)        # 输出形状: [batch, 2048, 1, 1]
        x = paddle.flatten(x, start_axis=1)  # 输出形状: [batch, 2048]
        x = self.projection(x)          # 输出形状: [batch, embedding_dim]
        # L2归一化,至关重要!
        x = F.normalize(x, p=2, axis=1)
        return x

3.3 实现三元组损失与困难样本挖掘

我们将实现一个带在线困难样本挖掘的三元组损失。这意味着我们会在一个批次内部,动态地为每个锚点寻找最困难的负样本和正样本。

class OnlineTripletLoss(nn.Layer):
    def __init__(self, margin=0.5):
        super(OnlineTripletLoss, self).__init__()
        self.margin = margin
    
    def forward(self, embeddings, labels):
        """
        embeddings: 批次内所有样本的特征向量,形状 [batch_size, embedding_dim]
        labels: 批次内所有样本的标签,形状 [batch_size]
        """
        batch_size = embeddings.shape[0]
        
        # 计算批次内所有样本对之间的欧氏距离矩阵
        # 利用公式 ||a-b||^2 = ||a||^2 + ||b||^2 - 2<a,b>
        # 由于embeddings已经L2归一化,||a||=||b||=1,所以距离平方 = 2 - 2*余弦相似度
        # 这里我们直接计算余弦相似度矩阵,然后转换为距离
        similarity_matrix = paddle.matmul(embeddings, embeddings, transpose_y=True)  # [batch, batch]
        distance_matrix = 1.0 - similarity_matrix  # 余弦距离,范围[0, 2]
        
        # 将标签扩展为矩阵,用于掩码操作
        labels_expanded = labels.unsqueeze(1)  # [batch, 1]
        label_eq_matrix = paddle.equal(labels_expanded, labels_expanded.T)  # [batch, batch] bool矩阵
        
        # 为每个锚点寻找最困难的正样本和负样本
        loss = paddle.zeros([1])
        valid_triplets = 0
        
        for i in range(batch_size):
            # 对于锚点i,找到所有正样本(不包括自己)
            pos_mask = label_eq_matrix[i] & (paddle.arange(batch_size) != i)
            # 找到所有负样本
            neg_mask = ~label_eq_matrix[i]
            
            if not pos_mask.any() or not neg_mask.any():
                continue  # 如果没有有效的正样本或负样本,跳过
                
            # 锚点到所有样本的距离
            anchor_distances = distance_matrix[i]
            
            # 最困难的正样本:距离锚点最远的正样本
            hardest_pos_dist = paddle.max(anchor_distances * pos_mask.astype('float32'))
            
            # 最困难的负样本:距离锚点最近的负样本
            # 给负样本距离加上一个很大的数乘以正样本掩码,确保最小值的候选只在负样本中
            neg_distances = anchor_distances + 1e6 * pos_mask.astype('float32')
            hardest_neg_dist = paddle.min(neg_distances)
            
            # 计算三元组损失
            triplet_loss = paddle.clip(hardest_pos_dist - hardest_neg_dist + self.margin, min=0.0)
            if triplet_loss > 0:
                loss += triplet_loss
                valid_triplets += 1
        
        if valid_triplets == 0:
            return paddle.zeros([1], requires_grad=True)
        
        loss = loss / valid_triplets
        return loss

3.4 模型训练与评估

现在,我们把所有部分组装起来,开始训练模型。

def train_one_epoch(model, dataloader, criterion, optimizer, epoch):
    model.train()
    total_loss = 0.0
    
    for batch_idx, (anchor, positive, negative) in enumerate(dataloader):
        # 合并批次中的锚点、正样本、负样本
        # 假设 dataloader 返回的是三元组,我们需要为每个样本生成标签
        # 这里简化处理:假设一个批次中,每个三元组的锚点和正样本标签相同,负样本标签不同
        # 实际更复杂的实现需要根据你的数据加载逻辑来构造标签
        images = paddle.concat([anchor, positive, negative], axis=0)
        # 构造标签:例如,batch_size=32,则前32个是锚点,中间32个是正样本,最后32个是负样本
        # 我们假设每个三元组的锚点和正样本共享一个虚拟标签i,负样本用另一个标签
        # 这是一个简化的示例,真实场景需要根据你的数据配对来定义
        labels = paddle.arange(images.shape[0] // 3)
        labels = paddle.concat([labels, labels, labels + labels.max() + 1], axis=0)
        
        optimizer.clear_grad()
        embeddings = model(images)
        loss = criterion(embeddings, labels)
        loss.backward()
        optimizer.step()
        
        total_loss += loss.numpy()[0]
        
        if batch_idx % 10 == 0:
            print(f'Epoch [{epoch}], Batch [{batch_idx}/{len(dataloader)}], Loss: {loss.numpy()[0]:.4f}')
    
    avg_loss = total_loss / len(dataloader)
    print(f'Epoch [{epoch}] Average Loss: {avg_loss:.4f}')
    return avg_loss

# 初始化模型、损失函数和优化器
embedding_dim = 128
model = EmbeddingNet(embedding_dim)
criterion = OnlineTripletLoss(margin=0.5)
optimizer = paddle.optimizer.Adam(parameters=model.parameters(), learning_rate=1e-4)

# 训练循环
num_epochs = 20
for epoch in range(1, num_epochs + 1):
    train_one_epoch(model, dataloader, criterion, optimizer, epoch)
    # 这里可以添加验证逻辑和模型保存逻辑
    # paddle.save(model.state_dict(), f'checkpoint_epoch_{epoch}.pdparams')

训练完成后,我们可以使用模型来提取特征并进行人脸验证。验证时,计算两张图片特征向量的余弦相似度,设定一个阈值(如0.7),大于阈值则判定为同一人。

def verify_faces(model, img1_path, img2_path, threshold=0.7):
    transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
    
    img1 = Image.open(img1_path).convert('RGB')
    img2 = Image.open(img2_path).convert('RGB')
    
    img1_tensor = transform(img1).unsqueeze(0)
    img2_tensor = transform(img2).unsqueeze(0)
    
    model.eval()
    with paddle.no_grad():
        feat1 = model(img1_tensor)
        feat2 = model(img2_tensor)
    
    # 计算余弦相似度
    similarity = paddle.sum(feat1 * feat2).numpy()[0]  # 因为已经归一化,点积即余弦相似度
    
    is_same = similarity > threshold
    print(f"相似度: {similarity:.4f}, 是否同一人: {is_same}")
    return similarity, is_same

4. 进阶技巧与避坑指南

掌握了基础实现后,我们再来聊聊一些能让模型效果更上一层楼的进阶技巧,以及我这些年踩过的一些坑。

4.1 损失函数的选择与调参

选择损失函数没有银弹。我的经验是:

  • 如果你的数据有清晰的类别标签(比如人脸ID、商品品类),且类别数很多,首选ArcFace。它训练稳定,泛化能力强。调参重点是间隔和尺度因子。间隔决定了类间分离的强度,通常设置在0.1到0.5之间;尺度因子用于放大余弦值,使Softmax概率更“有区分度”,通常设置在30到64之间。一开始可以用默认值(间隔0.5,尺度64),然后根据验证集准确率微调。
  • 如果你的数据只有配对信息(相似/不相似),或者类别数很少,三元组损失及其变体更合适。这时,间隔是关键参数。间隔太小,模型学不到足够的区分性;间隔太大,可能导致训练困难、不收敛。可以从0.2开始尝试。务必结合在线困难样本挖掘,否则训练效率极低。
  • 可以尝试组合损失。例如,将基于分类的损失(如ArcFace)和基于样本对的损失(如三元组损失)加权相加。分类损失保证了大方向的正确性,样本对损失则能进一步精细化类内分布。权重比例需要仔细调整,我通常从1:1开始。

4.2 数据增强与特征工程的魔力

深度度量学习模型对数据质量非常敏感。

  • 数据增强是免费的午餐:对于图像任务,除了常用的随机裁剪、水平翻转,可以尝试更针对性的增强,如随机擦除、颜色抖动、MixUp或CutMix。这些增强能强迫模型不去关注那些偶然的、非本质的特征(比如特定的背景块),而是学习更鲁棒的身份特征。
  • 难样本的“制造”:在数据层面,可以有意收集一些困难样本,比如不同光照、夸张表情、重度遮挡的人脸,或者不同角度、不同款式的同款商品。将这些样本加入训练集,能极大提升模型的实战能力。
  • 特征后处理:在推理阶段,对特征进行白化处理,有时能带来意想不到的效果提升。白化可以消除特征维度间的相关性,并使所有维度具有相同的方差,这通常能使特征空间更“各向同性”,提升度量效果。

4.3 模型部署与性能优化

模型训练好了,怎么用到实际产品中?

  • 模型轻量化:移动端或边缘设备对模型大小和速度有苛刻要求。可以考虑使用 MobileNetV3、EfficientNet-Lite 或 GhostNet 作为特征提取骨干网络。PaddlePaddle的PaddleClas套件里提供了丰富的预训练轻量模型,可以直接拿来微调。
  • 向量检索:人脸验证1:1比对很简单,但如果是海量库(如百万级)的1:N识别,逐对计算相似度是不可行的。这时需要引入向量检索库,如 FAISS、Milvus。它们能对高维向量建立索引,实现亚秒级的最近邻搜索。你需要将底库所有人的特征向量提前提取好并建索引,线上只需提取待查询图片的特征,然后进行检索即可。
  • 阈值动态化:固定的相似度阈值(如0.7)可能不是最优的。在实际应用中,可以根据应用场景的安全等级要求(如金融支付要求极高安全,社区门禁可以适当宽松),或者根据图像质量(模糊图片的阈值应调低),进行动态阈值调整。

我印象最深的一个坑是早期忽略了特征归一化。当时模型训练损失一直在下降,但验证集效果就是上不去,而且特征值范围波动很大。后来发现是忘记在特征输出后加L2归一化层,导致相似度计算不稳定。加上归一化后,效果立刻稳定提升。所以,记住这个黄金法则:进入度量空间前,先归一化。

深度度量学习是一个将抽象“相似性”概念数学化、可优化的美妙领域。从原理上看,它优雅而统一;从实战上看,它又充满了工程细节的挑战。希望这篇结合了原理剖析和PaddlePaddle实战的长文,能帮你打通从理论到实现的任督二脉。最关键的是动手去试,调整参数,观察损失曲线和验证结果,你会在不断的调试中对这项技术有更深刻的体会。

关于“Deep Adversarial Metric Learning” 论文阅读笔记 论文题目:Deep Adversarial Metric Learning 论文创新点:DAML利用大量 易辨识的负例( easy negatives)生成 难辨识的负例(hard negatives);现存的度量学习(metric learning)方法仅利用数量少的hard negatives而忽略数量多的easy negatives。如下图所示, 具体内容: DAML的网络结... 阅读详情

相关推荐

别再乱改基础库了!手把手教你搞定uni-app小程序上传图片报错(chooseAndUploadFile权限篇)

本文详细解析了uni-app开发微信小程序时遇到的`chooseAndUploadFile`权限报错问题,并提供了四步解决方案。从隐私协议与API权限的关联入手,指导开发者正确配置后台声明、双重提交策略和版本管理,避免降级基础库等常见误区,确保小程序合规运行。

weixin_33709364的博客 278

深度学习(17)—— 度量学习

昨天讨论的时候一个大佬提到了Metric Learning,听他讲了一下大致思路,觉得有点意思,所以下来了解了一下,简单记录。

羊羊的博客 2958

基于Qt实现的轻量级CAD画图软件

基于Qt开发的轻量级CAD应用程序

weixin_44954230的博客 5661

推荐项目:深度度量学习(Deep Metric Learning)

推荐项目:深度度量学习(Deep Metric Learning) deep_metric_learning Deep metric learning methods implemented in Chainer 项目地址: https://gitcode.com...

gitblog_00014的博客 751

多模态论文笔记——CogVLM和CogVLM2

本文详细介绍LoRA版本的多模态模型——CogVLM和CogVLM2。在SD3中使用其作为captioner基准模型的原因和优势。

haopinglianlian的博客 2205

深入剖析Zynq AMP模式下CPU1中断响应机制:从原理到创新实践

在异构计算领域,Zynq-7000系列SoC的AMP(Asymmetric Multiprocessing)模式堪称多核编程的瑞士军刀。独立运行环境:CPU0运行Linux,CPU1运行FreeRTOS或裸机程序硬件资源独占:CPU0管理DDR,CPU1使用OCM(片上内存)中断隔离:默认所有中断路由到CPU0这种架构非常适合需要实时响应的工业控制系统——比如用CPU0处理网络通信,CPU1负责电机控制。AMP模式下中断路由的底层原理多维度性能优化技巧工业级可靠性的实现方案。

QQ_778132974的博客 495

度量学习 度量函数 metric learning deep metric learning 深度度量学习

曼哈顿距离(CityBlockSimilarity) 同欧式距离相似,都是用于多维数据空间距离的测度。 欧式距离(Euclidean Distance) 用于衡量多维空间中各个点之间的绝对距离。使用时各个维度量级最好能够在同一个尺度上。 马氏距离(Mahalanobis distance) 一种有效的计算两个未知样本集的相似度的方法。与欧氏距离将所有维度同等看待不同,其考虑到各种...

心之所向 2万+

64.企业级案例(上)-金融行业DDD落地全流程支付系统-附架构演进图

本文以金融支付系统为例,完整展示了DDD在企业级项目中的落地流程。首先通过事件风暴识别核心业务领域,包括交易、渠道、账务等限界上下文。在战略设计中划分上下文边界,确定交易上下文为核心域。战术设计聚焦交易上下文,详细设计了支付单聚合、值对象和支付路由服务。架构实现采用CQRS+EDA模式,通过命令端处理交易,查询端异步更新读模型,并利用防腐层隔离外部渠道。案例展示了DDD从业务探索到架构实现的全过程,体现了其在复杂业务系统中的价值。

yonggeit的博客 3042

深度度量学习小综述

深度度量学习:对比损失[1]首次将深度神经网络引入度量学习,它只约束类内对的特征尽量近而类间对的特征尽量远,三元组损失[2]在对比损失的基础上进一步考虑了类内对与类间对之间的相对关系,首先固定一个锚点样本(anchor),希望包含该样本的类间对(anchor-negative)特征的距离能够比同样包含该样本的类间对特征的距离大一个间隔。由于三元组损失一次采样三个样本,虽然能够同时考虑类间距、类内距以及二者的相对关系,但没有充分利用每个batch内的所有样本,因此[3]提出在一个batch内建立稠密的成对(p

weixin_38817895的博客 1260

用 OP-TEE 给 AI 模型“上锁”:密文存储、TEE 解密放行、推理后销毁(实战可落地)

本文提出一种基于OP-TEE的AI模型保护方案,通过两级密钥体系确保模型静态存储为密文,运行时仅在TEE内解密。方案采用KEK+DEK架构,DEK永不出TEE,支持分块解密与可验证擦除。该方案能有效防御静态分析、应用层逆向等威胁,但需承认其物理级攻击的局限性。文章详细描述了端到端架构、文件格式设计及TA实现要点,包括密钥管理、分块解密策略和销毁机制,为设备侧AI部署提供了工程可行的安全解决方案。

Interview_TC的博客 294

人形机器人维护保养指南:硬件工程师必备手册

随着科技的不断进步,人形机器人在各个领域的应用越来越广泛。本指南的目的是为硬件工程师提供一份系统、全面的人形机器人维护保养手册,涵盖从基础概念到实际操作的各个方面,帮助工程师们更好地理解和处理人形机器人在使用过程中出现的各种问题,确保机器人的正常运行。本文将首先介绍人形机器人维护保养涉及的核心概念,解释各硬件组件的原理和它们之间的关系;接着阐述维护保养的核心算法原理和具体操作步骤,结合数学模型进行详细讲解;然后通过项目实战案例展示如何在实际中应用这些知识;

AI天才研究院 966

PyTorch实现深度度量学习:Deep_Metric核心代码结构与模块分析

深度度量学习(Deep Metric Learning)是通过深度学习模型将样本映射到特征空间,使相似样本距离更近、不相似样本距离更远的技术。Deep_Metric项目基于PyTorch框架,提供了完整的深度度量学习解决方案,本文将深入解析其核心代码结构与模块设计,帮助开发者快速上手这一强大工具。 ## 项目整体架构概览 Deep_Metric采用模块化设计,将数据处理、模型构建、损失函数和评

gitblog_00263的博客 717

Vue3 - 详细实现微信公众号H5网页内置浏览器中预览下载word文档(doc)、excel表格(xls)、ppt文稿、pdf文档等文件,微信内部直接打开预览和下载到本地教程,安卓苹果手机无差异兼容

vue3,nuxt3,微信公众号,h5,移动端,网页,网站,vue微信内置浏览器下载文件,下载文件,在微信浏览器里面实现下载任意文件,H5需要在微信浏览器中下载excel文件,实现网页在微信内置浏览器中下载文件详细教程,安卓点击下载会提示打开浏览器,后端返回流文件,如何解决无法下载文件,跳转至浏览器下载文件,发送到电脑微信,安卓,苹果,手机系统,微信H5页面,vue3微信公众号H5网站,内置浏览器下载文档,如何在微信浏览器中预览office文件,word文档,excel文档,pdf文档,ppt文档,offi

🏆 前端领域优质创作者 1万+

PyTorch Metric Learning采样器深度解析:从MPerClass到分层采样

在深度学习度量学习领域,PyTorch Metric Learning库提供了强大而灵活的采样器组件,帮助优化训练过程中的数据采样策略。采样器在度量学习中扮演着关键角色,它们决定了模型在训练时看到的数据分布,直接影响模型性能和收敛速度。🚀 ## 采样器在度量学习中的重要性 度量学习的目标是学习一个嵌入空间,使得相似样本在该空间中距离较近,而不相似样本距离较远。采样器通过智能地选择训练样本,能

gitblog_01176的博客 1261

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

如何使用PyTorch Metric Learning构建高效双流度量学习模型:完整指南

PyTorch Metric Learning是一个模块化、灵活且可扩展的深度学习度量学习库,能帮助开发者轻松实现各种度量学习模型。本文将详细介绍如何使用该库构建强大的双流度量学习模型,让你的应用在图像检索、特征匹配等任务中表现更出色。 ## 什么是双流度量学习? 双流度量学习是一种特殊的深度学习架构,通过两个并行的神经网络分支(流)处理不同类型或不同视角的数据,然后学习它们之间的相似性度量。

gitblog_00798的博客 517

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

Deep Metric Learning核心算法解析与实战应用指南

本文深入解析Deep Metric Learning(DML)核心算法及其在工业场景中的实战应用。从度量学习基础概念到ArcFace、Triplet Loss等关键算法实现,结合人脸识别案例详细讲解数据准备、模型选型和训练技巧,并针对特征漂移、计算效率等生产环境挑战提供解决方案。

a1b2c的博客 170

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

从人脸识别到图像检索:Deep Metric Learning实战指南(附Paddle代码)

本文深入探讨Deep Metric Learning(DML)在计算机视觉中的应用,从人脸识别到图像检索,提供基于PaddlePaddle的实战指南。通过核心原理解析、环境搭建、模型设计到训练优化的全流程讲解,帮助开发者掌握度量学习技术,实现高效的图像相似性计算。

egg99的博客 604

从理论到实践:Deep_Metric支持的6种损失函数全面对比与选择指南

深度度量学习是现代计算机视觉和图像检索领域的核心技术,而**损失函数**的选择直接影响模型的性能表现。Deep_Metric项目作为一个强大的深度度量学习框架,提供了6种经典的损失函数实现,帮助开发者在不同场景下优化嵌入空间学习。本文将深入解析这些损失函数的原理、优缺点,并提供实用的选择指南,让你轻松掌握深度度量学习的核心技巧。 ## 🔍 深度度量学习损失函数概述 深度度量学习的目标是学习一

gitblog_00476的博客 681

深度度量学习实战指南:PyTorch Metric Learning自监督学习与MoCo对比学习

PyTorch Metric Learning是一个模块化、灵活且可扩展的深度度量学习库,为研究人员和开发者提供了丰富的工具集。在自监督学习领域,该库提供了强大的对比学习支持,特别是MoCo(Momentum Contrast)风格的实现,让无标签数据也能训练出高质量的视觉表示模型。本文将深入探讨如何使用PyTorch Metric Learning实现MoCo风格的自监督对比学习,帮助您快速掌握

gitblog_02491的博客 354

《深度余弦度量学习:行人重识别的判别性与鲁棒性之源》

传统的特征学习方法通常关注于学习特征向量的模长和方向。这种映射方式的好处在于,它消除了特征向量模长对相似性计算的影响,使得相似性的判断只依赖于向量的方向。其中,(\vec{A}) 和 (\vec{B}) 分别表示两个特征向量,(\cdot) 表示向量的点积,(||\vec{A}||) 和 (||\vec{B}||) 分别表示向量 (\vec{A}) 和 (\vec{B}) 的模长。这样,模型就能够学习到一种能够将同一行人的图像特征向量映射到相近位置,而将不同行人的图像特征向量映射到远离位置的映射方式。

weixin_41544125的博客 1356

PyTorch Metric Learning与TensorFlow Similarity对比:哪个更适合你的项目?

PyTorch Metric Learning和TensorFlow Similarity是两个最流行的深度度量学习框架。PyTorch Metric Learning作为应用中最简单使用深度度量学习的方式,提供了模块化、灵活和可扩展的解决方案。本文将深入对比这两个框架的功能特性、易用性和性能表现,帮助你做出明智的选择。🚀 ## 框架架构对比:模块化 vs 一体化 ### PyTorch M

gitblog_01154的博客 696

【算法分析】深度余弦度量学习与物体跟踪 算法解析

目录 深度余弦度量学习Deep Cosine Metric Learning 深度余弦度量学习Deep Cosine Metric Learning 解决什么问题 Deep SORT 如何使用余弦度量Deep Cosine进行物体跟踪 深度余弦度量学习Deep Cosine Metric Learning 论文: http://elib.dlr.de/116408/ 代码: https...

HaoBBNuanMM的博客 3668

PyTorch Metric Learning挖掘器指南:如何高效选择困难样本对

PyTorch Metric Learning是一个强大的深度学习度量学习库,其核心功能之一就是**样本挖掘器**(miners)。在度量学习中,挖掘器负责从大量可能的样本对中智能地挑选出那些能够提供最大训练价值的困难样本对,从而显著提升模型性能。本文将为你详细介绍如何高效使用PyTorch Metric Learning中的各种挖掘器。 ## 什么是样本挖掘器? 样本挖掘器是度量学习中的关键

gitblog_00475的博客 768

Revisiting Deep Metric Learning PyTorch 项目教程

Revisiting Deep Metric Learning PyTorch 项目教程 1. 项目目录结构及介绍 Revisiting_Deep_Metric_Learning_PyTorch/ ├── architectures/ │ ├── __init__.py │ └── ... ├── batchminer/ │ ├── __init__.py │ └── ... ├─...

gitblog_00704的博客 327

PyTorch Metric Learning分布式训练:多GPU加速与跨批次内存技术终极指南

PyTorch Metric Learning是一个强大的深度学习度量学习库,它为分布式训练提供了完整的解决方案。通过多GPU加速和跨批次内存技术,你可以显著提升模型训练效率和性能。本指南将带你深入了解如何利用这些技术来优化你的度量学习项目。 ## 为什么选择分布式训练? 分布式训练是处理大规模数据集和复杂模型的**关键技术**。在度量学习中,我们经常需要处理高维嵌入空间和复杂的相似性计算,这

gitblog_00646的博客 902
上一篇: Simscape Multibody旋转关节初始角度设置全攻略(附30度案例详解)
下一篇: MIPI M-PHY协议解析:高速数据传输的核心技术及其跨平台应用
linux6sysadmin
博客等级 码龄4年 59粉丝 1615原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值