使用PyTorch来进展不平衡数据集的图像分类

【Pytorch学习笔记】8.训练类别不均衡数据时,如何使用WeightedRandomSampler(权重采样器) 阅读详情

作者:Marek Paulik

编译:ronghuaiyang

导读

一个非常简单和容易上手的例子。

对于教程中使用的大多数人工数据集,每个类都有相同数量的数据。然而,在实际应用中,这种情况很少发生。今天,我将给你介绍来自Kaggle的木薯叶分类,并告诉你当类频率有很大差异时该怎么做。

处理类别的不平衡

有两种方法可以解决这个问题。

  • WeightedRandomSampler

  • loss函数中的weight参数

下一步是创建一个有5个方法的CassavaClassifier类:load_data()、load_model()、fit_one_epoch()、val_one_epoch()和fit()。

在load_data()中,将构造一个train和验证数据集,并返回数据加载器以供进一步使用。

在load_model()中定义了体系结构、损失函数和优化器。

fit方法包含一些初始化和对fit_one_epoch()和val_one_epoch()的循环。

早期停止

早期停止类有助于根据验证损失跟踪最佳模型,并保存检查点。

#Callbacks
# Early stopping
class EarlyStopping:
  def __init__(self, patience=1, delta=0, path='checkpoint.pt'):
    self.patience = patience
    self.delta = delta
    self.path= path
    self.counter = 0
    self.best_score = None
    self.early_stop = False

  def __call__(self, val_loss, model):
    if self.best_score is None:
      self.best_score = val_loss
      self.save_checkpoint(model)
    elif val_loss > self.best_score:
      self.counter +=1
      if self.counter >= self.patience:
        self.early_stop = True 
    else:
      self.best_score = val_loss
      self.save_checkpoint(model)
      self.counter = 0      

  def save_checkpoint(self, model):
    torch.save(model.state_dict(), self.path)

Init

我们首先初始化CassavaClassifier类。

class CassavaClassifier():
    def __init__(self, data_dir, num_classes, device, Transform=None, sample=False, loss_weights=False, batch_size=16,
     lr=1e-4, stop_early=True, freeze_backbone=True):
    #############################################################################################################
    # data_dir - directory with images in subfolders, subfolders name are categories
    # Transform - data augmentations
    # sample - if the dataset is imbalanced set to true and RandomWeightedSampler will be used
    # loss_weights - if the dataset is imbalanced set to true and weight parameter will be passed to loss function
    # freeze_backbone - if using pretrained architecture freeze all but the classification layer
    ###############################################################################################################
        self.data_dir = data_dir
        self.num_classes = num_classes
        self.device = device
        self.sample = sample
        self.loss_weights = loss_weights
        self.batch_size = batch_size
        self.lr = lr
        self.stop_early = stop_early
        self.freeze_backbone = freeze_backbone
        self.Transform = Transform

Load Data

训练图像被组织在子文件夹中,子文件夹名称表示图像的类。这是图像分类问题的典型情况,幸运的是,不需要编写自定义数据集类。在这种情况下,可以立即使用torchvision中的ImageFolder。如果你想使用WeightedRandomSampler,你需要为数据集的每个元素指定一个权重。通常,总图像总比上类别数被用作一个权重。

def load_data(self):
    train_full = torchvision.datasets.ImageFolder(self.data_dir, transform=self.Transform)
    train_set, val_set = random_split(train_full, [math.floor(len(train_full)*0.8), math.ceil(len(train_full)*0.2)])

    self.train_classes = [label for _, label in train_set]
    if self.sample:
        # Need to get weight for every image in the dataset
        class_count = Counter(self.train_classes)
        class_weights = torch.Tensor([len(self.train_classes)/c for c in pd.Series(class_count).sort_index().values]) 
        # Can't iterate over class_count because dictionary is unordered

        sample_weights = [0] * len(train_set)
        for idx, (image, label) in enumerate(train_set):
            class_weight = class_weights[label]
            sample_weights[idx] = class_weight

        sampler = WeightedRandomSampler(weights=sample_weights,
                                        num_samples = len(train_set), replacement=True)  
        train_loader = DataLoader(train_set, batch_size=self.batch_size, sampler=sampler)
    else:
        train_loader = DataLoader(train_set, batch_size=self.batch_size, shuffle=True)

    val_loader = DataLoader(val_set, batch_size=self.batch_size)

    return train_loader, val_loader

Load Model

在该方法中,我使用迁移学习,架构参数从预先训练的resnet50和efficientnet-b7中选择。CrossEntropyLoss和许多其他损失函数都有权重参数。这是一个手动调整参数,用于处理不平衡。在这种情况下,不需要为每个参数定义权重,只需为每个类定义权重。

def load_model(self, arch='resnet'):
    ##############################################################################################################
    # arch - choose the pretrained architecture from resnet or efficientnetb7
    ############################################################################################################## 
    if arch == 'resnet':
        self.model = torchvision.models.resnet50(pretrained=True)
        if self.freeze_backbone:
            for param in self.model.parameters():
                param.requires_grad = False
        self.model.fc = nn.Linear(in_features=self.model.fc.in_features, out_features=self.num_classes)
    elif arch == 'efficient-net':
        self.model = EfficientNet.from_pretrained('efficientnet-b7')
        if self.freeze_backbone:
            for param in self.model.parameters():
                param.requires_grad = False
        self.model._fc = nn.Linear(in_features=self.model._fc.in_features, out_features=self.num_classes)    

    self.model = self.model.to(self.device)

    self.optimizer = torch.optim.Adam(self.model.parameters(), self.lr) 

    if self.loss_weights:
        class_count = Counter(self.train_classes)
        class_weights = torch.Tensor([len(self.train_classes)/c for c in pd.Series(class_count).sort_index().values])
        # Cant iterate over class_count because dictionary is unordered
        class_weights = class_weights.to(self.device)  
        self.criterion = nn.CrossEntropyLoss(class_weights)
    else:
        self.criterion = nn.CrossEntropyLoss() 

Fit One Epoch

这个方法只包含一个经典的训练循环,带有训练损失记录和tqdm进度条。

def fit_one_epoch(self, train_loader, epoch, num_epochs ): 
    step_train = 0

    train_losses = list() # Every epoch check average loss per batch 
    train_acc = list()
    self.model.train()
    for i, (images, targets) in enumerate(tqdm(train_loader)):
        images = images.to(self.device)
        targets = targets.to(self.device)

        logits = self.model(images)
        loss = self.criterion(logits, targets)

        loss.backward()
        self.optimizer.step()

        self.optimizer.zero_grad()

        train_losses.append(loss.item())

        #Calculate running train accuracy
        predictions = torch.argmax(logits, dim=1)
        num_correct = sum(predictions.eq(targets))
        running_train_acc = float(num_correct) / float(images.shape[0])
        train_acc.append(running_train_acc)
        
    train_loss = torch.tensor(train_losses).mean()    
    print(f'Epoch {epoch}/{num_epochs-1}')  
    print(f'Training loss: {train_loss:.2f}')

Validate one epoch

与上面类似,但此方法在验证数据加载器上迭代。在每一个epoch'之后,平均batch损失和准确性被打印出来。

def val_one_epoch(self, val_loader, scaler):
        val_losses = list()
        val_accs = list()
        self.model.eval()
        step_val = 0
        with torch.no_grad():
            for (images, targets) in val_loader:
                images = images.to(self.device)
                targets = targets.to(self.device)

                logits = self.model(images)
                loss = self.criterion(logits, targets)
                val_losses.append(loss.item())      
            
                predictions = torch.argmax(logits, dim=1)
                num_correct = sum(predictions.eq(targets))
                running_val_acc = float(num_correct) / float(images.shape[0])

                val_accs.append(running_val_acc)
            

            self.val_loss = torch.tensor(val_losses).mean()
            val_acc = torch.tensor(val_accs).mean() # Average acc per batch
        
            print(f'Validation loss: {self.val_loss:.2f}')  
            print(f'Validation accuracy: {val_acc:.2f}') 

Fit

Fit方法在训练和验证过程中经历了许多阶段和循环。如果预训练模型的参数在开始时被冻结,那么unfreeze_after定义了整个模型在多少个epoch之后开始训练。在此之前,只训练全连接层(分类器)。

def fit(self, train_loader, val_loader, num_epochs=10, unfreeze_after=5, checkpoint_dir='checkpoint.pt'):
    if self.stop_early:
        early_stopping = EarlyStopping(
        patience=5, 
        path=checkpoint_dir)
  
    for epoch in range(num_epochs):
        if self.freeze_backbone:
            if epoch == unfreeze_after:  # Unfreeze after x epochs
                for param in self.model.parameters():
                    param.requires_grad = True
        self.fit_one_epoch(train_loader, scaler, epoch, num_epochs)
        self.val_one_epoch(val_loader, scaler)
        if self.stop_early:
            early_stopping(self.val_loss, self.model)
            if early_stopping.early_stop:
                print('Early Stopping')
                print(f'Best validation loss: {early_stopping.best_score}')
                break

Run

现在,可以初始化CassavaClassifier类、创建dataloaders、设置模型并运行整个过程了。

Transform = T.Compose(
                    [T.ToTensor(),
                    T.Resize((256, 256)),
                    T.RandomRotation(90),
                    T.RandomHorizontalFlip(p=0.5),
                    T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))])

device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
data_dir = "Data/cassava-disease/train/train"

classifier = CassavaClassifier(data_dir=data_dir, num_classes=5, device=device, sample=True, Transform=Transform)
train_loader, val_loader = classifier.load_data()
classifier.load_model()
classifier.fit(num_epochs=20, unfreeze_after=5, train_loader=train_loader, val_loader=val_loader)

Inference

使用ImageFolder加载测试数据是不可能的,因为显然没有带有类的子文件夹。因此,我创建了一个返回图像和图像id的自定义数据集。随后,加载模型检查点,通过推理循环运行它,并将预测保存到数据帧中。将数据帧导出为CSV并提交结果。

# Inference
model = torchvision.models.resnet50()
#model = EfficientNet.from_name('efficientnet-b7')
model.fc = nn.Linear(in_features=model.fc.in_features, out_features=5)
model = model.to(device)
checkpoint = torch.load('Data/cassava-disease/sampler_checkpoint.pt')
model.load_state_dict(checkpoint)
model.eval()


# Dataset for test data
class Cassava_Test(Dataset):
  def __init__(self, dir, transform=None):
    self.dir = dir
    self.transform = transform

    self.images = os.listdir(self.dir)  

  def __len__(self):
    return len(self.images)

  def __getitem__(self, idx):
    img = Image.open(os.path.join(self.dir, self.images[idx]))
    return self.transform(img), self.images[idx] 


test_dir = 'Data/cassava-disease/test/test/0'
test_set = Cassava_Test(test_dir, transform=Transform)
test_loader = DataLoader(test_set, batch_size=4)  

# Test loop
sub = pd.DataFrame(columns=['category', 'id'])
id_list = []
pred_list = []

model = model.to(device)

with torch.no_grad():
  for (image, image_id) in test_loader:
    image = image.to(device)

    logits = model(image)
    predicted = list(torch.argmax(logits, 1).cpu().numpy())

    for id in image_id:
      id_list.append(id)
  
    for prediction in predicted:
      pred_list.append(prediction)
sub['category'] = pred_list
sub['id'] = id_list

mapping = {0:'cbb', 1:'cbsd', 2:'cgm', 3:'cmd', 4:'healthy'}

sub['category'] = sub['category'].map(mapping)
sub = sub.sort_values(by='id')

sub.to_csv('Cassava_sub.csv', index=False)

如果在方案中包含WeightedRandomSampler或损失权值,则测试集的精度会提高2%。对于仅仅几行代码来说,这是一个很好的改进。对于这个数据集,我没有看到这两种方法在精度上的巨大差异,但WeightedRandomSampler的表现要好一些。

不同的学习速度、优化器和数据扩展肯定有自己的发展空间。然而,对于这种简单的方法来说,86%的准确率似乎足够好了。

—END—

英文原文:https://marekpaulik.medium.com/imbalanced-dataset-image-classification-with-pytorch-6de864982eb1

猫狗图像分类数据集与CNN实战指南 图像分类是计算机视觉的基础任务,通过卷积神经网络(CNN)自动提取特征实现物体识别。标准化数据集如猫狗分类数据集(128x128像素JPEG格式)能显著提升模型开发效率,其结构化命名和预处理节省了30%数据准备时间。这类数据集特别适合教学和快速原型验证,平衡了数据规模(21616张)与计算复杂度。实践中,PyTorch数据管道构建配合数据增强技术(如RandomHorizontalFlip)能有效提升模型泛化能力。迁移学习通过微调ResNet等预训练模型,可在小数据集上快速达到90%+准确率,是工程实践中的 阅读详情

相关推荐

PyTorch深度学习7天入门:从环境搭建到图像分类实战

深度学习作为人工智能的核心技术,通过神经网络模拟人脑学习机制实现智能决策。其原理基于反向传播算法自动优化模型参数,在计算机视觉、自然语言处理等领域展现巨大技术价值。PyTorch作为主流深度学习框架,凭借动态计算图的直观调试特性和接近NumPy的API设计,大幅降低了学习门槛和实验成本。在实际工程实践中,开发者需要系统掌握张量运算、自动微分、模型训练等核心概念,特别是GPU加速计算和内存管理对项目效率至关重要。本文基于PyTorch框架,通过CIFAR-10图像分类等实战案例,详解环境配置、数据加载、模型训

390

使用Pytorch实现不平衡数据集的图像分类

https://mp.weixin.qq.com/s/gpIP2sE5N3vzElpIPhTQZw

Andrew_SJ的博客 1049

解决数据不均衡问题的方法及源代码

数据不均衡指的是数据集中不同类别的样本数量差异较大,导致模型在训练和预测时对少数类别的样本预测效果较差。生成新特征法是通过在原始特征的基础上构建新的特征,从而增加分类器对少数类别的区分能力。常用的生成新特征的方法包括主成分分析(PCA)、线性判别分析(LDA)和核方法等。综上所述,解决数据不均衡问题的方法包括重采样法、生成新特征法、集成方法和类别权重法。类别权重法是通过为不同类别设置权重,从而调整分类器对不同类别的关注程度。常见的类别权重法包括设置样本权重、设置类别权重和设置损失函数权重等。

YovcGit的博客 287

使用PyTorch来进展训练过程

一个非常简单和容易上手的例子。 对于教程中使用的大多数人工数据集,每个类都有相同数量的数据。然而,在实际应用中,这种情况很少发生。今天,我将给你介绍来自Kaggle的木薯叶分类,并告诉你当类频率有很大差异时该怎么做。 处理类别的不平衡 有两种方法可以解决这个问题。 WeightedRandomSampler loss函数中的weight参数 下一步是创建一个有5个方法的CassavaClassifier类:load_data()、load_model()、fit_one_.

爱CV 1846

pytorch 14 训练数据不平衡下的解决方案

在实际项目进程中有时会碰到数据不平衡的情况,数据不平衡会导致训练过程中的loss/梯度不平衡,最终导致模型所学习到的知识有偏好。在部署模型时就会出现类型多的数据效果好,类型少的数据效果差。那么在解决问题就要从这三方面下手,让不平衡的数据变得平衡,让loss/梯度变得平衡,让模型在学习过程不受数据量的影响,变得无偏好。所提到的点不仅可以针对数值型数据,也可以针对图像型数据。 首先在这里给出一个基本定义,多数类:数量特别多的类别 少数类:数量较少的类别。后续中假设多数类为A,少数类为B。 1、让数.

a486259的博客 2562

从0到1:CNN征服CIFAR-10图像分类实战

本文介绍了基于CIFAR-10数据集的卷积神经网络(CNN)图像分类实战。首先概述了深度学习与CNN的基本原理,然后详细解析了CIFAR-10数据集的构成、特点及其在图像分类任务中的优势。接着阐述了开发环境的搭建过程,包括工具库安装和版本适配。在技术实现部分,重点讲解了数据预处理方法、CNN模型架构设计(包含卷积层、池化层和全连接层)以及模型训练优化过程。最后通过准确率、召回率等指标评估模型性能,并采用特征图可视化等方法分析模型表现。实验结果表明,所构建的CNN模型能有效实现图像分类,但在某些相似类别上仍存

远程部署调试 运行安装 项目调试 二次开发 项目技术新 持续迭代 部分源码免费分享 137

基于深度学习的图像分类:使用MobileNet实现高效分类

本文介绍了基于MobileNet的轻量级图像分类方法。首先阐述了图像分类的定义与医学、自动驾驶等应用场景,然后详细解析MobileNet架构的核心技术——深度可分离卷积,说明其通过将标准卷积分解为深度卷积和逐点卷积来减少计算量的优势。文章提供了完整的PyTorch实现流程,包括数据预处理、预训练模型加载、分类层调整、模型训练与评估等关键步骤。实验使用CIFAR-10数据集,展示了MobileNet在保持较高精度的同时显著降低计算复杂度的特点。最后建议读者可尝试其他轻量级模型或更大规模的数据集应用。

qq_74383080的博客 1034

掌握CIFAR-10图像分类数据集:深度学习实践指南

CIFAR-10是一个广泛使用的数据集,由10个不同类别的60,000张32x32彩色图像组成,包含汽车、鸟、猫、鹿、狗、青蛙、马、船和卡车等类别。每个类别有6,000张图像,其中5,000张用作训练,1,000张用作测试。数据集的来源是加拿大高级研究所的机器学习组。CIFAR-10数据集在机器学习和深度学习中的重要性显而易见,因为它是一个实际场景的图像分类问题的标准数据集,被广泛应用于评估各种图像识别算法的性能。

weixin_42613017的博客 805

基于深度学习的图像分类:使用EfficientNet实现高效分类

本文介绍了基于EfficientNet的高效图像分类方法。EfficientNet通过复合缩放技术,系统性地平衡网络深度、宽度和分辨率,在保持高效性的同时显著提升性能。文章从理论基础出发,详细讲解了EfficientNet架构和复合缩放方法的特点与优势。在实践部分,提供了完整的PyTorch实现代码,包括数据预处理、模型加载与微调、训练评估等步骤,并以CIFAR-10数据集为例展示了完整的分类流程。实验结果表明,EfficientNet在保持高精度的同时显著降低了计算量,其灵活可扩展的特性使其适用于各类图像

qq_74383080的博客 1291

ConvNeXt V2图像分类实战:从FCMAE预训练到自定义数据集微调

卷积神经网络(CNN)作为计算机视觉的经典架构,以其固有的平移等变性和高效计算特性,在图像识别任务中长期占据重要地位。其核心原理是通过卷积核在图像上进行局部特征提取,并通过堆叠的层级结构构建从边缘到语义的抽象表征。随着自监督学习技术的发展,模型能够从海量无标签数据中学习通用视觉特征,显著提升了在下游任务上的泛化能力和数据效率。ConvNeXt V2正是这一技术趋势下的代表性工作,它通过引入全卷积掩码自编码器(FCMAE)预训练框架,使纯卷积架构也能进行掩码图像建模,从而学习到强大的视觉表征。在工程实践中,利

weixin_34401479的博客 467

mmdetection:图像分类与目标检测的深度学习框架

本文还有配套的精品资源,点击获取 简介:mmDetection是一个基于PyTorch的开源框架,专为图像分类和目标检测设计,支持多种经典和现代模型,如ResNet、VGG、EfficientNet等。它还集成了单阶段和两阶段检测器,如YOLO、SSD、Faster R-CNN等,并提供了模块化设计,简化了模型组合、调整和优化的流程。框架还包括数据处理、模型训练、验证和测试...

weixin_42600407的博客 2782

深度学习图像分类技术解析与实践指南

图像分类作为计算机视觉的基础任务,通过卷积神经网络(CNN)实现特征自动提取与模式识别。其核心技术包括卷积运算、池化操作等层次化特征提取机制,配合交叉熵损失函数和优化器完成端到端训练。随着ResNet等架构创新,深度学习在医疗影像分析、工业质检等场景展现出超越人类的识别能力。本文以PyTorch框架为例,详解从数据增强、模型训练到部署优化的全流程实践,特别针对类别不平衡、过拟合等实际问题提供解决方案,并探讨Vision Transformer等前沿方向的发展趋势。

weixin_34025051的博客 426

防雷防浪涌电路设计

通信线路或者电源线路通常会铺设到户外,一旦线路铺到户外后,就需要考虑防雷的问题了,那么怎么设计保护电路,能够防止雷电等浪涌对电路的破坏呢?

manhuami2007的博客 1万+

react-native-windows 自动化通道(automation-channel)深入解析:从 Node 客户端到 RNW 应用的 JSON-RPC 双向调用

`@react-native-windows/automation-channel` 是 react-native-windows(RNW)生态中用于支撑端到端(E2E)自动化测试的关键组件,它让同一台机器上的 Node.js 客户端能够通过远程过程调用(RPC)方式驱动运行中的 react-native-windows 应用。读完本文,你将掌握该通道的完整接入方式(Node 客户端 + C++

gitblog_01108的博客 388

SAP Script表单开发中ABAP preform方法的实战应用与调试技巧

本文深入探讨了在SAP Script表单开发中调用ABAP程序(preform方法)的实战应用与调试技巧。通过一个获取供应商版本名称的实例,详细讲解了如何在SE71中嵌入PERFORM指令、编写ABAP子程序进行数据查询与处理,并重点介绍了使用SAP Script Debugger进行高效调试的方法,帮助开发者灵活扩展表单功能,实现复杂业务逻辑。

o0p1q2r3的博客 554

【ComfyUI】【Nunchaku】【diffusers报错解决】秋叶整合包安装 Nunchaku 报错的解决方法

最近在折腾 AI 绘图时,我尝试在秋叶的 ComfyUI 整合包中安装 `ComfyUI-nunchaku` 插件(版本 0.3.3),结果启动后直接报错,提示无法从 `accelerate.utils.memory` 中导入 `clear_device_cache`,让我一度怀疑插件是否兼容。查阅了一堆 issue 和源码之后,总算找到了原因和解决方法。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 1865

PyTorch实现LDAM Loss:从0构建类别分布感知的损失函数

LDAM Loss(Label-Distribution-Aware Margin Loss)是NeurIPS 2019提出的解决类别不平衡问题的创新损失函数,通过动态调整类别边界,有效提升长尾分布数据的模型性能。本文将带你了解LDAM Loss的核心原理,并通过PyTorch实现从理论到实践的完整流程。 ## 为什么需要LDAM Loss? 在图像分类、自然语言处理等任务中,**类别不平衡*

gitblog_01155的博客 249

沁恒CH32V30X学习笔记02--GPIO的使用教程及2次封装驱动

刚复位后,GPIO 口运行在初始状态,这时大多数 IO 口都是运行在状态所有的 GPIO 口都可以被配置外部中断输入通道,但一个外部中断输入通道最多只能映射到一个GPIO 引脚上,且外部中断通道的序号必须和 GPIO 端口的位号一致,,两方都是一对一的关系。复用功能。

Car12 708

基于PyTorch与迁移学习的垃圾图像分类系统:从数据到API部署全流程实践

图像分类是计算机视觉的基础任务,其核心是让计算机识别图像中的物体所属类别。其原理通常依赖于卷积神经网络(CNN),该网络通过多层过滤器从低级特征(如边缘)逐步提取高级语义特征。这项技术的价值在于能将重复性视觉任务自动化,广泛应用于工业质检、医疗影像分析、自动驾驶等领域。在环保与智能化场景中,结合迁移学习技术,可以利用在大型数据集(如ImageNet)上预训练的模型,快速适配特定任务,例如垃圾自动分类。本文以垃圾分类为具体案例,详细阐述了使用PyTorch框架,通过数据收集、模型选择、训练优化到最终封装为RE

weixin_33796205的博客 355

基于深度学习的水质预测:多参数监测与预测

首先,我们需要收集水质监测的多参数数据。收集到的数据应包括不同时间点的水质参数值以及相应的水质等级标签,用于训练和评估深度学习模型。同时,数据的质量和数量对于模型的性能也有重要影响,因此在实际应用中需要充分考虑数据的采集和处理过程。总之,基于深度学习的水质预测可以通过收集水质监测的多参数数据并使用适当的深度学习模型进行训练和预测来实现。通过以上的深度学习模型,我们可以利用水质监测的多参数数据进行水质预测。这种基于深度学习的方法可以提高水质预测的准确性和稳定性,为水质监测和环境保护提供有力支持。

web_bug407的博客 1103

【小程序抓取】解决痛点:如何用 AI-RPA 工具抓取无法获取 URL 的微信小程序数据?

本文探讨了传统爬虫技术在微信小程序数据采集中的局限性,并提出了AI-RPA(人工智能驱动的机器人流程自动化)这一前沿解决方案。随着微信小程序安全防护体系的全面升级(包括证书锁定、加密传输和三级防御机制),传统"抓包-模拟请求"的方式已基本失效。文章对比了Reqable、Fiddler等主流抓包工具的优劣,通过某程旅行小程序案例展示了传统抓包的技术流程和动态参数处理的难点。最终指出,2026年最有效的解决方案是采用AI-RPA技术,通过视觉识别、鼠标键盘模拟、OCR和AI智能体编排的组合方案,直接从小程序UI

ZDQ58818的博客 124

Vision Transformer终极指南:从零掌握PyTorch实现

Vision Transformer(ViT)正在彻底改变计算机视觉领域,这个基于PyTorch的开源项目为开发者提供了完整的ViT实现方案。无论你是机器学习新手还是经验丰富的研究人员,这个指南将带你深入了解如何使用vit-pytorch库构建强大的图像识别模型。 ## 🔥 什么是Vision Transformer? Vision Transformer是一种将自然语言处理中的Transf

gitblog_01071的博客 1112

用 AI 设计力打造专业 UI_UX:在 Trea、Qoder 等 AI IDE 中集成 ui-ux-pro-max-skill

的核心是知识库Trea 和 Qoder 虽未被--ai all原生支持,但完全可通过@folder手动集成使用后,你的 AI 生成代码将从“功能可用”跃升至“设计专业”这是零成本提升产品质感的最佳实践之一🎨好的 UI 不应是设计师的专利,而是每个开发者的默认能力。然后在 Trea 或 Qoder 中输入—— 让 AI 成为你最懂设计的结对编程伙伴。

lpfasd123的博客 7109
上一篇: 谷歌用傅里叶变换替换Transformer自注意力层!在GPU上快7倍、TPU上快2倍...
下一篇: Github标星4.8K!微软开源的可视化工具,未免太酷炫了吧
机器学习算法那些事
博客等级 码龄9年 1633粉丝 62原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值