CLIP-ReID代码解读四——model文件夹（模型文件）

已于 2024-06-18 20:03:43 修改
阅读量386 收藏 2
点赞数 10
分类专栏： CLIP-ReID代码解读 文章标签： 深度学习
于 2024-06-18 09:58:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SisterRu/article/details/139763713
版权

make_model.py

import torch
import torch.nn as nn
import numpy as np
from .clip.simple_tokenizer import SimpleTokenizer as _Tokenizer
_tokenizer = _Tokenizer()  # 初始化一个简单的分词器实例
from timm.models.layers import DropPath, to_2tuple, trunc_normal_

# 定义一种初始化神经网络权重的函数
def weights_init_kaiming(m):
    classname = m.__class__.__name__
    if classname.find('Linear') != -1:
        # 如果是全连接层，使用kaiming_normal初始化权重，偏置设为0
        nn.init.kaiming_normal_(m.weight, a=0, mode='fan_out')
        nn.init.constant_(m.bias, 0.0)
    elif classname.find('Conv') != -1:
        # 如果是卷积层，使用kaiming_normal初始化权重，偏置设为0
        nn.init.kaiming_normal_(m.weight, a=0, mode='fan_in')
        if m.bias is not None:
            nn.init.constant_(m.bias, 0.0)
    elif classname.find('BatchNorm') != -1:
        # 如果是批量归一化层，权重设为1，偏置设为0
        if m.affine:
            nn.init.constant_(m.weight, 1.0)
            nn.init.constant_(m.bias, 0.0)

# 定义一种初始化分类器权重的函数
def weights_init_classifier(m):
    classname = m.__class__.__name__
    if classname.find('Linear') != -1:
        # 对全连接层权重使用标准正态分布初始化，偏置设为0
        nn.init.normal_(m.weight, std=0.001)
        if m.bias:
            nn.init.constant_(m.bias, 0.0)

# 定义Transformer模型构建类
class build_transformer(nn.Module):
    def __init__(self, num_classes, camera_num, view_num, cfg):
        super(build_transformer, self).__init__()
        self.model_name = cfg.MODEL.NAME
        self.cos_layer = cfg.MODEL.COS_LAYER
        self.neck = cfg.MODEL.NECK
        self.neck_feat = cfg.TEST.NECK_FEAT
        
        # 根据模型名称设置输入特征维度
        if self.model_name == 'ViT-B-16':
            self.in_planes = 768
            self.in_planes_proj = 512
        elif self.model_name == 'RN50':
            self.in_planes = 2048
            self.in_planes_proj = 1024
        
        self.num_classes = num_classes
        self.camera_num = camera_num
        self.view_num = view_num
        self.sie_coe = cfg.MODEL.SIE_COE
        
        # 初始化分类器
        self.classifier = nn.Linear(self.in_planes, self.num_classes, bias=False)
        self.classifier.apply(weights_init_classifier)
        self.classifier_proj = nn.Linear(self.in_planes_proj, self.num_classes, bias=False)
        self.classifier_proj.apply(weights_init_classifier)

        # 初始化瓶颈层（BatchNorm）
        self.bottleneck = nn.BatchNorm1d(self.in_planes)
        self.bottleneck.bias.requires_grad_(False)  # 不对BN层的偏置进行反向传播
        self.bottleneck.apply(weights_init_kaiming)
        self.bottleneck_proj = nn.BatchNorm1d(self.in_planes_proj)
        self.bottleneck_proj.bias.requires_grad_(False)
        self.bottleneck_proj.apply(weights_init_kaiming)

        # 计算图像分辨率
        self.h_resolution = int((cfg.INPUT.SIZE_TRAIN[0] - 16) // cfg.MODEL.STRIDE_SIZE[0] + 1)
        self.w_resolution = int((cfg.INPUT.SIZE_TRAIN[1] - 16) // cfg.MODEL.STRIDE_SIZE[1] + 1)
        self.vision_stride_size = cfg.MODEL.STRIDE_SIZE[0]
        
        # 加载 CLIP 模型
        clip_model = load_clip_to_cpu(self.model_name, self.h_resolution, self.w_resolution, self.vision_stride_size)
        clip_model.to("cuda")  # 将 CLIP 模型加载到 GPU 上
        self.image_encoder = clip_model.visual

        # 初始化 SIE 参数
        if cfg.MODEL.SIE_CAMERA and cfg.MODEL.SIE_VIEW:
            self.cv_embed = nn.Parameter(torch.zeros(camera_num * view_num, self.in_planes))
            trunc_normal_(self.cv_embed, std=.02)
            print('camera number is : {}'.format(camera_num))
        elif cfg.MODEL.SIE_CAMERA:
            self.cv_embed = nn.Parameter(torch.zeros(camera_num, self.in_planes))
            trunc_normal_(self.cv_embed, std=.02)
            print('camera number is : {}'.format(camera_num))
        elif cfg.MODEL.SIE_VIEW:
            self.cv_embed = nn.Parameter(torch.zeros(view_num, self.in_planes))
            trunc_normal_(self.cv_embed, std=.02)
            print('camera number is : {}'.format(view_num))

    def forward(self, x, label=None, cam_label=None, view_label=None):
        # 前向传播，基于不同的模型名称处理输入数据
        if self.model_name == 'RN50':
            image_features_last, image_features, image_features_proj = self.image_encoder(x)
            img_feature_last = nn.functional.avg_pool2d(image_features_last, image_features_last.shape[2:4]).view(x.shape[0], -1)
            img_feature = nn.functional.avg_pool2d(image_features, image_features.shape[2:4]).view(x.shape[0], -1)
            img_feature_proj = image_features_proj[0]
        elif self.model_name == 'ViT-B-16':
            if cam_label is not None and view_label is not None:
                cv_embed = self.sie_coe * self.cv_embed[cam_label * self.view_num + view_label]
            elif cam_label is not None:
                cv_embed = self.sie_coe * self.cv_embed[cam_label]
            elif view_label is not None:
                cv_embed = self.sie_coe * self.cv_embed[view_label]
            else:
                cv_embed = None
            image_features_last, image_features, image_features_proj = self.image_encoder(x, cv_embed)
            img_feature_last = image_features_last[:, 0]
            img_feature = image_features[:, 0]
            img_feature_proj = image_features_proj[:, 0]

        # 瓶颈层的特征
        feat = self.bottleneck(img_feature)
        feat_proj = self.bottleneck_proj(img_feature_proj)

        if self.training:
            # 训练阶段，返回分类器得分和特征
            cls_score = self.classifier(feat)
            cls_score_proj = self.classifier_proj(feat_proj)
            return [cls_score, cls_score_proj], [img_feature_last, img_feature, img_feature_proj]
        else:
            # 测试阶段，根据neck_feat参数决定返回的特征
            if self.neck_feat == 'after':
                return torch.cat([feat, feat_proj], dim=1)
            else:
                return torch.cat([img_feature, img_feature_proj], dim=1)

    def load_param(self, trained_path):
        # 从指定路径加载预训练模型参数
        param_dict = torch.load(trained_path)
        for i in param_dict:
            self.state_dict()[i.replace('module.', '')].copy_(param_dict[i])
        print('Loading pretrained model from {}'.format(trained_path))

    def load_param_finetune(self, model_path):
        # 从指定路径加载微调模型参数
        param_dict = torch.load(model_path)
        for i in param_dict:
            self.state_dict()[i].copy_(param_dict[i])
        print('Loading pretrained model for finetuning from {}'.format(model_path))

def make_model(cfg, num_class, camera_num, view_num):
    # 创建并返回一个build_transformer模型实例
    model = build_transformer(num_class, camera_num, view_num, cfg)
    return model

from .clip import clip
def load_clip_to_cpu(backbone_name, h_resolution, w_resolution, vision_stride_size):
    # 从CLIP模型下载并加载到CPU
    url = clip._MODELS[backbone_name]
    model_path = clip._download(url)

    try:
        model = torch.jit.load(model_path, map_location="cpu").eval()
        state_dict = None
    except RuntimeError:
        state_dict = torch.load(model_path, map_location="cpu")

    model = clip.build_model(state_dict or model.state_dict(), h_resolution, w_resolution, vision_stride_size)
    return model

代码注释

  1. 导入库和初始化：

    • import torch 和 import torch.nn as nn：导入 PyTorch 和神经网络模块。
    • import numpy as np：导入 NumPy，用于数值计算。
    • from .clip.simple_tokenizer import SimpleTokenizer as _Tokenizer：从本地模块导入简单的分词器。
    • from timm.models.layers import DropPath, to_2tuple, trunc_normal_：从 timm 库导入模型层的工具函数。

  2. 权重初始化函数：

    • weights_init_kaiming 和 weights_init_classifier：定义了两种权重初始化方式，分别用于普通层和分类层。

  3. Transformer 模型构建类：

    • class build_transformer(nn.Module)：定义了一个继承自 nn.Module 的类，用于构建 Transformer 模型。
    • __init__：构造函数，初始化模型的各个组件，包括分类器、瓶颈层和 CLIP 模型。
      • 根据模型名称初始化不同的参数。
      • 初始化分类器和瓶颈层，并应用相应的初始化函数。
      • 加载 CLIP 模型到 GPU，并提取图像编码器。
      • 初始化 SIE 参数（相机和视角）
      • load_param：从指定路径加载预训练模型参数。
      • load_param_finetune：从指定路径加载微调模型参数。

  4. 辅助函数：

    • make_model：创建并返回一个 build_transformer 模型实例。
    • load_clip_to_cpu：从 CLIP 模型下载并加载到 CPU 上。

make_model_clipreid.py

import torch
import torch.nn as nn
import numpy as np
from .clip.simple_tokenizer import SimpleTokenizer as _Tokenizer
_tokenizer = _Tokenizer()
from timm.models.layers import DropPath, to_2tuple, trunc_normal_

# 权重初始化函数，使用Kaiming方法初始化线性层、卷积层和BatchNorm层的权重
def weights_init_kaiming(m):
    classname = m.__class__.__name__
    if classname.find('Linear') != -1:
        nn.init.kaiming_normal_(m.weight, a=0, mode='fan_out')
        nn.init.constant_(m.bias, 0.0)
    elif classname.find('Conv') != -1:
        nn.init.kaiming_normal_(m.weight, a=0, mode='fan_in')
        if m.bias is not None:
            nn.init.constant_(m.bias, 0.0)
    elif classname.find('BatchNorm') != -1:
        if m.affine:
            nn.init.constant_(m.weight, 1.0)
            nn.init.constant_(m.bias, 0.0)

# 分类器权重初始化函数
def weights_init_classifier(m):
    classname = m.__class__.__name__
    if classname.find('Linear') != -1:
        nn.init.normal_(m.weight, std=0.001)
        if m.bias:
            nn.init.constant_(m.bias, 0.0)

# 文本编码器类，使用CLIP模型的Transformer和投影层来编码文本
class TextEncoder(nn.Module):
    def __init__(self, clip_model):
        super().__init__()
        self.transformer = clip_model.transformer
        self.positional_embedding = clip_model.positional_embedding
        self.ln_final = clip_model.ln_final
        self.text_projection = clip_model.text_projection
        self.dtype = clip_model.dtype

    def forward(self, prompts, tokenized_prompts):
        x = prompts + self.positional_embedding.type(self.dtype)
        x = x.permute(1, 0, 2)  # NLD -> LND
        x = self.transformer(x)
        x = x.permute(1, 0, 2)  # LND -> NLD
        x = self.ln_final(x).type(self.dtype)
        # 获取EOT（End of Text）标记的特征
        x = x[torch.arange(x.shape[0]), tokenized_prompts.argmax(dim=-1)] @ self.text_projection
        return x

# 构建Transformer模型类，用于图像和文本编码
class build_transformer(nn.Module):
    def __init__(self, num_classes, camera_num, view_num, cfg):
        super(build_transformer, self).__init__()
        self.model_name = cfg.MODEL.NAME
        self.cos_layer = cfg.MODEL.COS_LAYER
        self.neck = cfg.MODEL.NECK
        self.neck_feat = cfg.TEST.NECK_FEAT
        if self.model_name == 'ViT-B-16':
            self.in_planes = 768
            self.in_planes_proj = 512
        elif self.model_name == 'RN50':
            self.in_planes = 2048
            self.in_planes_proj = 1024
        self.num_classes = num_classes
        self.camera_num = camera_num
        self.view_num = view_num
        self.sie_coe = cfg.MODEL.SIE_COE

        # 分类器和瓶颈层初始化
        self.classifier = nn.Linear(self.in_planes, self.num_classes, bias=False)
        self.classifier.apply(weights_init_classifier)
        self.classifier_proj = nn.Linear(self.in_planes_proj, self.num_classes, bias=False)
        self.classifier_proj.apply(weights_init_classifier)
        self.bottleneck = nn.BatchNorm1d(self.in_planes)
        self.bottleneck.bias.requires_grad_(False)
        self.bottleneck.apply(weights_init_kaiming)
        self.bottleneck_proj = nn.BatchNorm1d(self.in_planes_proj)
        self.bottleneck_proj.bias.requires_grad_(False)
        self.bottleneck_proj.apply(weights_init_kaiming)

        # 计算输入图像的分辨率
        self.h_resolution = int((cfg.INPUT.SIZE_TRAIN[0]-16)//cfg.MODEL.STRIDE_SIZE[0] + 1)
        self.w_resolution = int((cfg.INPUT.SIZE_TRAIN[1]-16)//cfg.MODEL.STRIDE_SIZE[1] + 1)
        self.vision_stride_size = cfg.MODEL.STRIDE_SIZE[0]
        
        # 加载CLIP模型
        clip_model = load_clip_to_cpu(self.model_name, self.h_resolution, self.w_resolution, self.vision_stride_size)
        clip_model.to("cuda")
        self.image_encoder = clip_model.visual

        # 摄像机和视角嵌入初始化
        if cfg.MODEL.SIE_CAMERA and cfg.MODEL.SIE_VIEW:
            self.cv_embed = nn.Parameter(torch.zeros(camera_num * view_num, self.in_planes))
            trunc_normal_(self.cv_embed, std=.02)
            print('camera number is : {}'.format(camera_num))
        elif cfg.MODEL.SIE_CAMERA:
            self.cv_embed = nn.Parameter(torch.zeros(camera_num, self.in_planes))
            trunc_normal_(self.cv_embed, std=.02)
            print('camera number is : {}'.format(camera_num))
        elif cfg.MODEL.SIE_VIEW:
            self.cv_embed = nn.Parameter(torch.zeros(view_num, self.in_planes))
            trunc_normal_(self.cv_embed, std=.02)
            print('view number is : {}'.format(view_num))

        dataset_name = cfg.DATASETS.NAMES
        self.prompt_learner = PromptLearner(num_classes, dataset_name, clip_model.dtype, clip_model.token_embedding)
        self.text_encoder = TextEncoder(clip_model)

    def forward(self, x=None, label=None, get_image=False, get_text=False, cam_label=None, view_label=None):
        # 获取文本特征
        if get_text:
            prompts = self.prompt_learner(label)
            text_features = self.text_encoder(prompts, self.prompt_learner.tokenized_prompts)
            return text_features

        # 获取图像特征
        if get_image:
            image_features_last, image_features, image_features_proj = self.image_encoder(x)
            if self.model_name == 'RN50':
                return image_features_proj[0]
            elif self.model_name == 'ViT-B-16':
                return image_features_proj[:, 0]

        # 获取图像特征并处理相机和视角嵌入
        if self.model_name == 'RN50':
            image_features_last, image_features, image_features_proj = self.image_encoder(x)
            img_feature_last = nn.functional.avg_pool2d(image_features_last, image_features_last.shape[2:4]).view(x.shape[0], -1)
            img_feature = nn.functional.avg_pool2d(image_features, image_features.shape[2:4]).view(x.shape[0], -1)
            img_feature_proj = image_features_proj[0]
        elif self.model_name == 'ViT-B-16':
            if cam_label is not None and view_label is not None:
                cv_embed = self.sie_coe * self.cv_embed[cam_label * self.view_num + view_label]
            elif cam_label is not None:
                cv_embed = self.sie_coe * self.cv_embed[cam_label]
            elif view_label is not None:
                cv_embed = self.sie_coe * self.cv_embed[view_label]
            else:
                cv_embed = None
            image_features_last, image_features, image_features_proj = self.image_encoder(x, cv_embed)
            img_feature_last = image_features_last[:, 0]
            img_feature = image_features[:, 0]
            img_feature_proj = image_features_proj[:, 0]

        feat = self.bottleneck(img_feature)
        feat_proj = self.bottleneck_proj(img_feature_proj)

        if self.training:
            cls_score = self.classifier(feat)
            cls_score_proj = self.classifier_proj(feat_proj)
            return [cls_score, cls_score_proj], [img_feature_last, img_feature, img_feature_proj], img_feature_proj
        else:
            if self.neck_feat == 'after':
                # 测试时使用BN后的特征
                return torch.cat([feat, feat_proj], dim=1)
            else:
                return torch.cat([img_feature, img_feature_proj], dim=1)

    # 加载预训练模型参数
    def load_param(self, trained_path):
        param_dict = torch.load(trained_path)
        for i in param_dict:
            self.state_dict()[i.replace('module.', '')].copy_(param_dict[i])
        print('Loading pretrained model from {}'.format(trained_path))

    def load_param_finetune(self, model_path):
        param_dict = torch.load(model_path)
        for i in param_dict:
            self.state_dict()[i].copy_(param_dict[i])
        print('Loading pretrained model for finetuning from {}'.format(model_path))

# 创建模型的函数
def make_model(cfg, num_class, camera_num, view_num):
    model = build_transformer(num_class, camera_num, view_num, cfg)
    return model

from .clip import clip
# 加载CLIP模型到CPU
def load_clip_to_cpu(backbone_name, h_resolution, w_resolution, vision_stride_size):
    url = clip._MODELS[backbone_name]
    model_path = clip._download(url)

    try:
        # 尝试加载JIT模型
        model

 = torch.jit.load(model_path, map_location="cpu").eval()
        state_dict = None
    except RuntimeError:
        state_dict = torch.load(model_path, map_location="cpu")

    model = clip.build_model(state_dict or model.state_dict(), h_resolution, w_resolution, vision_stride_size)
    return model

# 提示词学习器类，生成适合特定任务的提示词
class PromptLearner(nn.Module):
    def __init__(self, num_class, dataset_name, dtype, token_embedding):
        super().__init__()
        if dataset_name == "VehicleID" or dataset_name == "veri":
            ctx_init = "A photo of a X X X X vehicle."
        else:
            ctx_init = "A photo of a X X X X person."

        ctx_dim = 512
        # 初始化上下文向量
        ctx_init = ctx_init.replace("_", " ")
        n_ctx = 4

        tokenized_prompts = clip.tokenize(ctx_init).cuda()
        with torch.no_grad():
            embedding = token_embedding(tokenized_prompts).type(dtype)
        self.tokenized_prompts = tokenized_prompts  # torch.Tensor

        n_cls_ctx = 4
        cls_vectors = torch.empty(num_class, n_cls_ctx, ctx_dim, dtype=dtype)
        nn.init.normal_(cls_vectors, std=0.02)
        self.cls_ctx = nn.Parameter(cls_vectors)

        # 保存这些令牌向量
        self.register_buffer("token_prefix", embedding[:, :n_ctx + 1, :])
        self.register_buffer("token_suffix", embedding[:, n_ctx + 1 + n_cls_ctx:, :])
        self.num_class = num_class
        self.n_cls_ctx = n_cls_ctx

    def forward(self, label):
        cls_ctx = self.cls_ctx[label]
        b = label.shape[0]
        prefix = self.token_prefix.expand(b, -1, -1)
        suffix = self.token_suffix.expand(b, -1, -1)

        prompts = torch.cat(
            [
                prefix,  # (n_cls, 1, dim)
                cls_ctx,  # (n_cls, n_ctx, dim)
                suffix,  # (n_cls, *, dim)
            ],
            dim=1,
        )

        return prompts
yiruzhao
关注
专栏目录
《CLIP-ReID Exploiting Vision-Language Model for Image Re-identification without Concrete Text Label》
三明治的博客
03-10 1620
像CLIP这样的预训练视觉语言模型最近在包括图像分类和分割在内的各种下游任务上显示出优越的性能。然而，在细粒度图像再识别(ReID)中，标签是索引，缺乏具体的文本描述。因此，如何将这些模型应用于这些任务还有待确定。提出了一个两阶段的策略，以促进更好的视觉表现。关键思想是通过为每个ID提供一组可学习的文本标记，充分利用CLIP中的跨模态描述能力，并将其提供给文本编码器以形成模糊描述。第一个训练阶段，只有文本标记通过计算的对比损失从头开始优化。在第二阶段，为微调图像编码器提供了约束
P-DukeMTMC-reID.zip
02-27
《行人多属性重识别数据集：P-DukeMTMC-reID》 在计算机视觉领域，行人识别是一项重要的任务，尤其在安全监控、智能交通和人脸识别系统中有着广泛的应用。P-DukeMTMC-reID（Person-DukeMTMC-reID）是一个专为此目的...
ComfyUI 中你不得不了解的插件，IPAdapter 基础的使用
2401_84760527的博客
05-24 7428
IPAdapter 是一个轻量级的适配器，它的作用是将一张图像或几张图像的风格迁移到另一张图像上去，可以把它当作只有一张图像的 lora。通俗的讲就是垫图。IPAdapter 接受一张图像作为输入，将其编码为Token，并和标准的提示词输入混合作用于图像的生成。
深度学习系列37：CLIP模型
热门推荐
kittyzc的博客
06-07 2万+
含义：CLIP（Contrastive Language-Image Pre-training） git地址：https://github.com/openai/CLIP paper：https://arxiv.org/abs/2103.00020 安装：pip install git+https://github.com/openai/CLIP.git
多模态对比语言图像预训练CLIP：打破语言与视觉的界限
丨汀、的博客
10-31 430
多模态对比语言图像预训练CLIP：打破语言与视觉的界限
【计算机视觉】如何利用 CLIP 做简单的图像分类任务？（含源代码）
wzk4869的博客
05-15 8747
【计算机视觉】如何利用 CLIP 做简单的图像分类任务？（含源代码）
comfyUi核心节点
最新发布
AiPlayerShow的博客
06-16 6239
为了方便快速搭建工作流，实现工作流程的结果，通常会搭建自定义的节点、扩展来达成目的。例如汉化自定义节点扩展ComfyUI-Translation。通常存放在custom_nodes目录下，可以通过面板安装节点或者卸载这些节点。
0197-极智芯-解读芯片禁令及英伟达特供芯片系列
06-02
0197_极智芯_解读芯片禁令及英伟达特供芯片系列
Celeb-reID:标量神经元以外的数据集和代码
04-24
名人 该存储库包含我们的论文数据集和代码》 和。 1.数据集 您可以直接从OneDrive 及其版本... Celeb-reID-light的数据拆分如下： 分裂 训练 询问 画廊 全部的 ＃ID 490 100 100 590 ＃图片 9021 887 934 1
DukeMTMC-VideoReID-master.zip_DukeMTMC-VideoReID_DukeMTMC-reID_d
07-15
此数据集提供的代码库包含了一些基础的行人再识别模型实现，如`baseline.py`，这是一个简单的基线模型，通常用于评估新算法的性能。`run.py`和`run.sh`则是运行模型的脚本，它们可以帮助用户快速地在数据集上训练和...
CLIP大模型运行demo
12-12
CLIP大模型运行demo
CLIP的model.py学习笔记
曦晨
01-11 893
CLIP在github上的代码目录如下图 （左）所示，目录的展开图如下图 （右）所示，CLIP代码的模型部分在/clip文件夹下的model.py文件中，这个文件是后面重点剖析对象。/date文件夹下面为一些说明文件，/notebooks文件夹下是一些关于如何测试CLIP的教程。/ModelPt文件夹下是作者预训练的一些模型，是本地部署的时候下载加入的，在github上的代码没有这部分。此帖用于本人课程学习报告的支撑材料。
ComfyUI一键更换服装：IP-Adapter V2 + FaceDetailer(DeepFashion)
程序员小麦的博客
05-14 3309
在这篇文章中，我们将探索如何使用新版的IP-Adapter和ComfyUI软件为人物进行换装。整个过程非常简单，仅需要两张图片：一张服装图片和一张人物图片。通过一系列节点的操作，ComfyUI就会把这个服装换到人物身上，并利用FaceDetailer节点来修复任何细微的服装问题。
第二十章 原理篇：CLIP
小闹钟的机器学习时间
07-24 2506
简要介绍clip的原理和代码实现。
PyTorch学习系列(九)——参数_初始化
genous110的博客
02-18 7457
本文转自如下： https://www.cnblogs.com/lindaxin/p/8037561.html https://blog.csdn.net/qq_19598705/article/details/80396047 之前我学习了神经网络中权值初始化的方法 那么如何在pytorch里实现呢。 PyTorch提供了多种参数初始化函数： torch.nn.init.constant(ten...
CLIP 源码分析：simple_tokenizer.py
qq_53324833的博客
05-28 851
不难发现，simple_tokenizer.py 这个文件模块就是用来处理我们输入的文本数据的，主要是一些编码上的处理、文本数据的清洗以及文本格式的转换。在最后我们会手动 debug 走一遍流程，看看该项目的各个部分到底是怎么做的都负责了什么。
pytorch参数初始化方法
邹小驴
10-11 1835
参数的初始化其实就是对参数赋值。 所以我们可以进行如下操作进行初始化，当然其实有其他的方法，但是这种方法是PyTorch作者所推崇的： import torch.nn.init as init import的语句 def weights_init_classifier(m): classname = m.__class__.__name__#得到网络层次的名字，如Convtran...
[深度学习TF2][RNN-NPL数据预处理] -Tokenizer函数
Harry的博客
05-12 1461
TF2-Tokenizer函数1. 背景介绍2. 函数Tokenizer 介绍2.1 设置要保留多少个高频词汇，2.2 训练数据集， 得到一个统计信息2.3 把单词转化为词向量2.4 把每一条数据（比如电影评论）甚至最大单词数量。3. 完整测试代码 1. 背景介绍 因为现在Tensorflow2.x 以后你要用RNN比如LSTM训练你的数据， 比如你要训练一个情感二分类。 那么数据要做预处理，因为你喂给你的模型的数据都是词向量了而不是字母单词或汉字。 那么怎么把你的单词或汉字转化为词向量呢。就要用到Toke
【Paddle CLIP】你写啥他画啥，一个专属于你的小画家
m0_63642362的博客
11-13 614
根据文本描述检索出相关的图像 CLIP
deep-person-reid源码目录中的configs文件夹是干嘛用的
05-05
`deep-person-reid` 是一个用于行人重识别的深度学习库，configs 文件夹中包含了一些预定义的配置文件，用于训练和测试深度学习模型。这些配置文件包含了模型的架构、损失函数、优化器、训练和测试的超参数等信息。通过修改这些配置文件，可以方便地调整模型的参数和超参数，以满足不同的需求和任务。同时，这些配置文件也提供了一些经过验证的最佳实践，可以帮助用户更快地构建出高性能的行人重识别模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yiruzhao

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值