在pytorch中使用用npz文件保存的预训练模型

最新推荐文章于 2024-04-02 10:37:47 发布
最新推荐文章于 2024-04-02 10:37:47 发布
阅读量1.1w 收藏 100
点赞数 26
分类专栏： 深度学习跳坑日志
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44020747/article/details/115208672
版权

开始

最近在看transformer相关的文章，在AN IMAGE IS WORTH 16X16 WORDS:
TRANSFORMERS FOR IMAGE RECOGNITION AT SCALE这篇文章中，作者给出了在超大数据集上训练的模型。但是采用的是npz文件保存。这里将介绍npz文件和如何将其应用到pytorch中进行加载参数和训练。

1、什么是npz文件？

npz文件是python中numpy的文件存储。
使用方法如下：

from numpy import load
data = load('D:/CsdnProject/TransUNet-main/ViT-B_16.npz')
lst = data.files
for item in lst:
    print(item)
    print(data[item])

采用load的方式进行加载。然后打印其内容（其中加载路径为这次的预训练模型的路径）

2、如何将预训练模型加载到pytorch中进行使用？

2.1预训练模型npz文件中的内容

首先，npz文件中存放的内容有两个内容，一个是模型中每个模块的名称，第二个是这个模块保存的参数。
如1所示代码

from numpy import load
from os.path import join as join
data = load('D:/CsdnProject/TransUNet-main/ViT-B_16.npz')
lst = data.files
for item in lst:
    print(item)
    print(data[item])

将其打印出来的结果是（未显示参数）

C:\Users\sg\Anaconda3\envs\pytorch\python.exe D:/CsdnProject/TransUNet-main/TestNpz.py
Transformer/encoder_norm/bias
Transformer/encoder_norm/scale
Transformer/encoderblock_0/LayerNorm_0/bias
Transformer/encoderblock_0/LayerNorm_0/scale
Transformer/encoderblock_0/LayerNorm_2/bias
Transformer/encoderblock_0/LayerNorm_2/scale
Transformer/encoderblock_0/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_0/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_0/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_0/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_0/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_1/LayerNorm_0/bias
Transformer/encoderblock_1/LayerNorm_0/scale
Transformer/encoderblock_1/LayerNorm_2/bias
Transformer/encoderblock_1/LayerNorm_2/scale
Transformer/encoderblock_1/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_1/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_1/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_1/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_1/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_10/LayerNorm_0/bias
Transformer/encoderblock_10/LayerNorm_0/scale
Transformer/encoderblock_10/LayerNorm_2/bias
Transformer/encoderblock_10/LayerNorm_2/scale
Transformer/encoderblock_10/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_10/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_10/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_10/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_10/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_11/LayerNorm_0/bias
Transformer/encoderblock_11/LayerNorm_0/scale
Transformer/encoderblock_11/LayerNorm_2/bias
Transformer/encoderblock_11/LayerNorm_2/scale
Transformer/encoderblock_11/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_11/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_11/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_11/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_11/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_2/LayerNorm_0/bias
Transformer/encoderblock_2/LayerNorm_0/scale
Transformer/encoderblock_2/LayerNorm_2/bias
Transformer/encoderblock_2/LayerNorm_2/scale
Transformer/encoderblock_2/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_2/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_2/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_2/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_2/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_3/LayerNorm_0/bias
Transformer/encoderblock_3/LayerNorm_0/scale
Transformer/encoderblock_3/LayerNorm_2/bias
Transformer/encoderblock_3/LayerNorm_2/scale
Transformer/encoderblock_3/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_3/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_3/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_3/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_3/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_4/LayerNorm_0/bias
Transformer/encoderblock_4/LayerNorm_0/scale
Transformer/encoderblock_4/LayerNorm_2/bias
Transformer/encoderblock_4/LayerNorm_2/scale
Transformer/encoderblock_4/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_4/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_4/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_4/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_4/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_5/LayerNorm_0/bias
Transformer/encoderblock_5/LayerNorm_0/scale
Transformer/encoderblock_5/LayerNorm_2/bias
Transformer/encoderblock_5/LayerNorm_2/scale
Transformer/encoderblock_5/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_5/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_5/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_5/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_5/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_6/LayerNorm_0/bias
Transformer/encoderblock_6/LayerNorm_0/scale
Transformer/encoderblock_6/LayerNorm_2/bias
Transformer/encoderblock_6/LayerNorm_2/scale
Transformer/encoderblock_6/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_6/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_6/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_6/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_6/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_7/LayerNorm_0/bias
Transformer/encoderblock_7/LayerNorm_0/scale
Transformer/encoderblock_7/LayerNorm_2/bias
Transformer/encoderblock_7/LayerNorm_2/scale
Transformer/encoderblock_7/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_7/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_7/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_7/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_7/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_8/LayerNorm_0/bias
Transformer/encoderblock_8/LayerNorm_0/scale
Transformer/encoderblock_8/LayerNorm_2/bias
Transformer/encoderblock_8/LayerNorm_2/scale
Transformer/encoderblock_8/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_8/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_8/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_8/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_8/MultiHeadDotProductAttention_1/value/kernel
Transformer/encoderblock_9/LayerNorm_0/bias
Transformer/encoderblock_9/LayerNorm_0/scale
Transformer/encoderblock_9/LayerNorm_2/bias
Transformer/encoderblock_9/LayerNorm_2/scale
Transformer/encoderblock_9/MlpBlock_3/Dense_0/bias
Transformer/encoderblock_9/MlpBlock_3/Dense_0/kernel
Transformer/encoderblock_9/MlpBlock_3/Dense_1/bias
Transformer/encoderblock_9/MlpBlock_3/Dense_1/kernel
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/key/bias
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/key/kernel
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/out/bias
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/out/kernel
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/query/bias
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/query/kernel
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/value/bias
Transformer/encoderblock_9/MultiHeadDotProductAttention_1/value/kernel
Transformer/posembed_input/pos_embedding
cls
embedding/bias
embedding/kernel
head/bias
head/kernel
pre_logits/bias
pre_logits/kernel

Process finished with exit code 0

2.2如何使用

所以我们要将这些内容一一赋值给我们定义的模型，我们定义的模型一定要和这些预训练的模型是一致的。
这里比如说我使用的是VIT-B-16，这意味着我的block有12个（具体参见论文），打印出我网络的模型后，其实两者是相同的。

在VisionTransformer类中，定义一个load_from函数，来给我的模型进行赋值

     def load_from(self, weights):
        with torch.no_grad():

            res_weight = weights
            #给嵌入块赋参数
            self.transformer.embeddings.patch_embeddings.weight.copy_(np2th(weights["embedding/kernel"], conv=True))
            self.transformer.embeddings.patch_embeddings.bias.copy_(np2th(weights["embedding/bias"]))
            # 给编码器赋参数
            self.transformer.encoder.encoder_norm.weight.copy_(np2th(weights["Transformer/encoder_norm/scale"]))
            self.transformer.encoder.encoder_norm.bias.copy_(np2th(weights["Transformer/encoder_norm/bias"]))
            # 给位置嵌入赋参数
            posemb = np2th(weights["Transformer/posembed_input/pos_embedding"])

            posemb_new = self.transformer.embeddings.position_embeddings
            print("1执行到这里了")
            if posemb.size() == posemb_new.size():
                #这里是true 下面全都不执行 直接到下个循环 循环那里有问题
                self.transformer.embeddings.position_embeddings.copy_(posemb)
                print("2执行到这里了")
            elif posemb.size()[1]-1 == posemb_new.size()[1]:
                posemb = posemb[:, 1:]
                self.transformer.embeddings.position_embeddings.copy_(posemb)
                print("3执行到这里了")
            else:
                logger.info("load_pretrained: resized variant: %s to %s" % (posemb.size(), posemb_new.size()))
                print("4执行到这里了")
                ntok_new = posemb_new.size(1)
                if self.classifier == "seg":
                    _, posemb_grid = posemb[:, :1], posemb[0, 1:]
                    print("5执行到这里了")
                gs_old = int(np.sqrt(len(posemb_grid)))
                gs_new = int(np.sqrt(ntok_new))
                print('load_pretrained: grid-size from %s to %s' % (gs_old, gs_new))
                posemb_grid = posemb_grid.reshape(gs_old, gs_old, -1)
                zoom = (gs_new / gs_old, gs_new / gs_old, 1)
                posemb_grid = ndimage.zoom(posemb_grid, zoom, order=1)  # th2np
                posemb_grid = posemb_grid.reshape(1, gs_new * gs_new, -1)
                posemb = posemb_grid
                self.transformer.embeddings.position_embeddings.copy_(np2th(posemb))
                print("6执行到这里了")
            print("7执行到这里了")

            # Encoder whole
            #分别给我的编码器中每一个层赋权重和偏置
            for bname, block in self.transformer.encoder.named_children():
                print(bname)
                print(block)
                for uname, unit in block.named_children():
                    print(uname)
                    print(unit)
                    unit.load_from(weights, n_block=uname)

            print("执行到这里了")

            if self.transformer.embeddings.hybrid:
                self.transformer.embeddings.hybrid_model.root.conv.weight.copy_(np2th(res_weight["conv_root/kernel"], conv=True))
                gn_weight = np2th(res_weight["gn_root/scale"]).view(-1)
                gn_bias = np2th(res_weight["gn_root/bias"]).view(-1)
                self.transformer.embeddings.hybrid_model.root.gn.weight.copy_(gn_weight)
                self.transformer.embeddings.hybrid_model.root.gn.bias.copy_(gn_bias)

                for bname, block in self.transformer.embeddings.hybrid_model.body.named_children():
                    for uname, unit in block.named_children():
                        unit.load_from(res_weight, n_block=bname, n_unit=uname)

再for循环中，block调用一个load_from函数，这个函数来自于block类。是这个类中的一个函数

    def load_from(self, weights, n_block):
        ROOT = f"Transformer/encoderblock_{n_block}/"
        with torch.no_grad():
            query_weight = np2th(weights[pjoin(ROOT, ATTENTION_Q, "kernel")]).view(self.hidden_size, self.hidden_size).t()
            key_weight = np2th(weights[pjoin(ROOT, ATTENTION_K, "kernel")]).view(self.hidden_size, self.hidden_size).t()
            value_weight = np2th(weights[pjoin(ROOT, ATTENTION_V, "kernel")]).view(self.hidden_size, self.hidden_size).t()
            out_weight = np2th(weights[pjoin(ROOT, ATTENTION_OUT, "kernel")]).view(self.hidden_size, self.hidden_size).t()

            query_bias = np2th(weights[pjoin(ROOT, ATTENTION_Q, "bias")]).view(-1)
            key_bias = np2th(weights[pjoin(ROOT, ATTENTION_K, "bias")]).view(-1)
            value_bias = np2th(weights[pjoin(ROOT, ATTENTION_V, "bias")]).view(-1)
            out_bias = np2th(weights[pjoin(ROOT, ATTENTION_OUT, "bias")]).view(-1)

            self.attn.query.weight.copy_(query_weight)
            self.attn.key.weight.copy_(key_weight)
            self.attn.value.weight.copy_(value_weight)
            self.attn.out.weight.copy_(out_weight)
            self.attn.query.bias.copy_(query_bias)
            self.attn.key.bias.copy_(key_bias)
            self.attn.value.bias.copy_(value_bias)
            self.attn.out.bias.copy_(out_bias)

            mlp_weight_0 = np2th(weights[pjoin(ROOT, FC_0, "kernel")]).t()
            mlp_weight_1 = np2th(weights[pjoin(ROOT, FC_1, "kernel")]).t()
            mlp_bias_0 = np2th(weights[pjoin(ROOT, FC_0, "bias")]).t()
            mlp_bias_1 = np2th(weights[pjoin(ROOT, FC_1, "bias")]).t()

            self.ffn.fc1.weight.copy_(mlp_weight_0)
            self.ffn.fc2.weight.copy_(mlp_weight_1)
            self.ffn.fc1.bias.copy_(mlp_bias_0)
            self.ffn.fc2.bias.copy_(mlp_bias_1)

            self.attention_norm.weight.copy_(np2th(weights[pjoin(ROOT, ATTENTION_NORM, "scale")]))
            self.attention_norm.bias.copy_(np2th(weights[pjoin(ROOT, ATTENTION_NORM, "bias")]))
            self.ffn_norm.weight.copy_(np2th(weights[pjoin(ROOT, MLP_NORM, "scale")]))
            self.ffn_norm.bias.copy_(np2th(weights[pjoin(ROOT, MLP_NORM, "bias")]))

3、坑

在执行过程中，给我报了一个值错误，意思就是没有找到值

KeyError: 'Transformer/encoderblock_0/MultiHeadDotProductAttention_1/query\\kernel is not a file in the archive'

在我多方面的查找，纠错后，发现错误原因是我在block类中，load_from函数下面的路径传的不对。

query_weight = np2th(weights[pjoin(ROOT, ATTENTION_Q, "kernel")]).view(self.hidden_size, self.hidden_size).t()

如上这句代码，连接了ROOT，ATTENTION_Q和kernel这三个路径。而连接过程中“/”的错误导致找不到这句话，所以会报错。

沙琪玛sqm
关注
  • 26
    点赞
  • 踩
  • 100
    收藏
    觉得还不错? 一键收藏
  • 45
    评论
专栏目录
PyTorch加载预训练模型实例(pretrained)
09-18
今天小编就为大家分享一篇PyTorch加载预训练模型实例(pretrained)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
ViT-Tinkoff-task
04-13
ViT-Tinkoff任务 要求： imagenet21k_ViT-B_16.npz imagenet21k_R50 + ViT-B_16.npz 可以从这里下载： : 链接：
向量数据库实战介绍
最新发布
小张学AI
04-02 1012
本文简单介绍了三种常见的向量数据库：faiss, Milvus, Qdrant，每种向量数据库都有其利弊。同时，结合一个具体的应用案例：文本相似性搜索，来分别展示这三种向量数据库的使用方法。
minst npz文件.rar
04-24
上传资源为mnist npz文件，keras亲测可用，大家若没有积分下载，可以去本人这篇博客查看，该博客中提供了百度网盘下载链接和提取码，永久有效。好用记得点赞哦
如何打开.npz文件
qq_43391414的博客
07-08 3万+
.npz文件是一个numpy格式的压缩文件，所以由numpy打开。 import numpy as np file_path="D:\Download\\tang.npz" poem=np.load(file_path,allow_pickle=True) poem.files 一般上面的输出内容随着不同的.npz文件不同而不同。但是我们总是可以如下处理。 ix2word,word2ix,data=poem['ix2word'],poem['word2ix'],poem['data'] type(ix
chatgpt赋能python：Python如何读取npz文件？
suimodina的博客
06-17 2665
npz 文件是一个多个数组数据的压缩文件格式，它是由 numpy 提供的一种数据存储格式。在处理大量的科学计算数据时，npz 是一个非常好的方式。当我们需要处理多个数组数据时，可以使用 npz 文件将它们压缩成一个文件，这样可以方便的存储和传输这些数组数据。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。
NPZ文件
qq_50799276的博客
04-12 1896
NPZ文件
Python中.npz文件的读取
热门推荐
学无止境、积少成多、厚积薄发
03-03 8万+
有时候从网上下载的数据集扩展名（后缀名）是npz，我们需要对数据进行加载（读取）： 例如：识别猫狗图片的二分类，下的数据集分别为cat.npz和dog.npz import numpy as np cat_data = np.load(‘cat.npz’) dog_data = np.load(‘dog.npz’) 因为以npz结尾的数据集是压缩文件，里面还有其他的文件 使用：cat_data.f...
在python中读取npz文件
znsoft的专栏
02-07 1万+
import numpy as np npz_path="D:\\NER-Research\\CLUENER2020\\BiLSTM-CRF\\data\\clue\\train.npz" # words.npy lables.npy data=np.load(npz_path,allow_pickle=True) for item in data.files: print(data[item] ) 在某个npz文件中，复制一份，修改扩展名为zip, 打开后，你会发现它有两个文件，wo.
Python中数据处理（npz、npy、csv文件；元组、列表、numpy数组的使用）
m0_51626061的博客
07-12 4247
Python中数据处理（npz、npy、csv文件；元组、列表、numpy数组的使用）
关于一些文件格式的问题（npz、npy、pb）
m0_61894078的博客
11-02 767
【.npz和.npy文件的关系是：.npy只能把一个numpy数组存为二进制，而.npz能把很多个numpy数组存为二进制，可以说.npz是多个.npy文件的打包】二、.npy文件：将numpy生成的数组保存成二进制格式的数据，也就是单个的np.array类型的数据。2. 读取.npy文件：【data=np.load('xxx.npy'),这里运行结果是显示一个数组】1. 创建.npy文件：【np.save('存储路径')，要存储的变量名】1.创建.npz:【np.savez('地址'，要存的变量)】
Face-Recognition:在Pytorch上使用内置在Arcface上的预训练模型进行人脸识别
05-04
使用ARCFACE-Pytorch的人脸识别 介绍 此存储库包含face_verify.py和app.py，它们能够执行以下任务- 从图像，视频或网络摄像头中检测脸部并进行脸部识别。 app.py用于部署项目。 所需文件 requirements.txt 预训练模型或 。 自定义数据集 新训练的模型（facebank.pth和names.npy） 用户说明 首先下载项目后，您必须安装以下库。 安装 您可以通过从终端运行以下命令来一次安装所有依赖项。 $ pip install - r requirements . txt 对于使用“ pip”安装割炬，请运行以下命令 $ pip3 install torch == = 1.2 . 0 torchvision == = 0.4 . 0 - f https : // download . pytorch . org /
pytorch 实现在预训练模型的 input上增减通道
09-18
今天小编就为大家分享一篇pytorch 实现在预训练模型的 input上增减通道，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Pytorch加载部分预训练模型的参数实例
09-18
今天小编就为大家分享一篇Pytorch加载部分预训练模型的参数实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
使用pytorch搭建AlexNet操作(微调预训练模型及手动搭建)
12-23
本文介绍了如何在pytorch下搭建AlexNet，使用了两种方法，一种是直接加载预训练模型，并根据自己的需要微调（将最后一层全连接层输出由1000改为10），另一种是手动搭建。 构建模型类的时候需要继承自torch.nn.Module...
基于pytorch的中文语言模型预训练模型源码
03-23
基于pytorch的中文语言模型预训练模型源码
NeRF-pytorch预训练模型
11-07
https://drive.google.com/drive/folders/1jIr8dkvefrQmv737fFm2isiT6tqpbTbv
npz的存取
AI_dataloads的博客
11-06 305
NPZ 是一种文件格式，它是 NumPy 库为了方便存储和读取大型数组而设计的。这种文件格式将多个 NumPy 数组保存在一个文件中，可以方便地在不同的计算机和操作系统之间共享和传输。
深度学习入门之如何制作npz、npy文件
weixin_43487442的博客
10-10 2万+
一、需求 论文《EyeTracking for everyone》中提出了iTracker神经网络，并构建了一个叫GazeCapture的数据库，将其部分数据集下载后，可以看到文件的层次结构如下图所示： 其中，整个数据集的后缀名是npz，内部文件的后缀名是npy。由于该数据集是面向Apple产品系列的，而我的目标是面向笔记本电脑的，需要根据要求制作自己的数据集，这就涉及到如何去制作npz和npy格式的文件。 二、npz文件和npy文件 首先需要了解，在深度学习的数据集格式中，常用的有csv、json、np
pytorch 使用预训练模型
09-16
在PyTorch中使用预训练模型的方法有两种。一种是使用torchvision.models提供的预训练模型，另一种是使用torch.utils.model_zoo提供的预训练模型。下面是这两种方法的详细说明： 1. 使用torchvision.models提供的预训练模型： import torchvision.models as models resnet18 = models.resnet18(pretrained=True) alexnet = models.alexnet(pretrained=True) ... 这种方法将会下载预训练模型并加载其权重。你可以通过调用对应的模型函数并传递pretrained=True来使用已经训练好的模型。例如，上述代码中的resnet18就是使用预训练模型加载的ResNet-18模型。 2. 使用torch.utils.model_zoo提供的预训练模型： import torch.utils.model_zoo as model_zoo resnet18 = model_zoo.load_url('https://download.pytorch.org/models/resnet18-5c106cde.pth') alexnet = model_zoo.load_url('https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth') ... 这种方法需要通过传递预训练模型的URL来加载模型。你可以使用model_zoo.load_url函数并传递对应模型的URL来加载已经训练好的模型。 综上所述，如果你想在PyTorch中使用预训练模型，可以选择使用torchvision.models提供的预训练模型或者使用torch.utils.model_zoo提供的预训练模型。具体使用哪种方法取决于你的需求和偏好。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 45
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值