pytorch笔记

最新推荐文章于 2024-09-04 08:22:11 发布
最新推荐文章于 2024-09-04 08:22:11 发布
阅读量159 收藏
点赞数
分类专栏： 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjinyyzyq/article/details/91995285
版权 
In [1]: import torchvision                                                      

In [2]: import torch                                                            

In [3]: import torch.nn as nn                                                   

In [4]: alex = torchvision.models.alexnet(pretrained=False)                     

In [5]: alex?                                                                   
Signature:       alex(*input, **kwargs)
Type:            AlexNet
String form:    
AlexNet(
           (features): Sequential(
           (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), pa <...> rue)
           (5): ReLU(inplace)
           (6): Linear(in_features=4096, out_features=1000, bias=True)
           )
           )
File:            ~/anaconda3/lib/python3.6/site-packages/torchvision/models/alexnet.py
Docstring:       <no docstring>
Class docstring:
Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing to nest them in
a tree structure. You can assign the submodules as regular attributes::

    import torch.nn as nn
    import torch.nn.functional as F

    class Model(nn.Module):
        def __init__(self):
            super(Model, self).__init__()
            self.conv1 = nn.Conv2d(1, 20, 5)
            self.conv2 = nn.Conv2d(20, 20, 5)

        def forward(self, x):
           x = F.relu(self.conv1(x))
           return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will have their
parameters converted too when you call :meth:`to`, etc.

In [6]: torchvision.models.AlexNet?                                             
Init signature: torchvision.models.AlexNet(num_classes=1000)
Docstring:     
Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing to nest them in
a tree structure. You can assign the submodules as regular attributes::

    import torch.nn as nn
    import torch.nn.functional as F

    class Model(nn.Module):
        def __init__(self):
            super(Model, self).__init__()
            self.conv1 = nn.Conv2d(1, 20, 5)
            self.conv2 = nn.Conv2d(20, 20, 5)

        def forward(self, x):
           x = F.relu(self.conv1(x))
           return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will have their
parameters converted too when you call :meth:`to`, etc.
File:           ~/anaconda3/lib/python3.6/site-packages/torchvision/models/alexnet.py
Type:           type

In [7]: class realex(alex): 
   ...:     def __init__(self): 
   ...:         super().__init__() 
   ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
   ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
   ...:     def forward(self, x): 
   ...:         x = F.relu(self.conv1(x)) 
   ...:         return F.relu(self.conv2(x)) 
   ...:                                                                                                                                                                                                             
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-e07645723006> in <module>
----> 1 class realex(alex):
      2     def __init__(self):
      3         super().__init__()
      4         self.conv1 = nn.Conv1d(1, 20, 5)
      5         self.conv2 = nn.Conv2d(20, 20, 6)

TypeError: __init__() takes from 1 to 2 positional arguments but 4 were given

In [8]: class realex(nn.Module): 
   ...:     def __init__(self): 
   ...:         super().__init__() 
   ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
   ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
   ...:     def forward(self, x): 
   ...:         x = F.relu(self.conv1(x)) 
   ...:         return F.relu(self.conv2(x)) 
   ...:                                                                                                                                                                                                             

In [9]: class realex(torchvision.models.AlexNet): 
   ...:     def __init__(self): 
   ...:         super().__init__() 
   ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
   ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
   ...:     def forward(self, x): 
   ...:         x = F.relu(self.conv1(x)) 
   ...:         return F.relu(self.conv2(x)) 
   ...:                                                                                                                                                                                                             

In [10]: realex                                                                                                                                                                                                     
Out[10]: __main__.realex

In [11]: realexx = realex()                                                                                                                                                                                         

In [12]: realexx                                                                                                                                                                                                    
Out[12]: 
realex(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace)
    (3): Dropout(p=0.5)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
  (conv1): Conv1d(1, 20, kernel_size=(5,), stride=(1,))
  (conv2): Conv2d(20, 20, kernel_size=(6, 6), stride=(1, 1))
)

In [13]: class realex(torchvision.models.AlexNet): 
    ...:     def __init__(self): 
    ...:         #super().__init__() 
    ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
    ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
    ...:     def forward(self, x): 
    ...:         x = F.relu(self.conv1(x)) 
    ...:         return F.relu(self.conv2(x)) 
    ...:                                                                                                                                                                                                            

In [14]: realexx                                                                                                                                                                                                    
Out[14]: 
realex(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace)
    (3): Dropout(p=0.5)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
  (conv1): Conv1d(1, 20, kernel_size=(5,), stride=(1,))
  (conv2): Conv2d(20, 20, kernel_size=(6, 6), stride=(1, 1))
)

In [15]: import os                                                                                                                                                                                                  

In [16]: os.system('vim ~/anaconda3/lib/python3.6/site-packages/torchvision/models/alexnet.py')                                                                                                                     
Out[16]: 0

In [17]: class realex(torchvision.models.AlexNet): 
    ...:     def __init__(self): 
    ...:         super().__init__() 
    ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
    ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
    ...:     def forward(self, x): 
    ...:         x = F.relu(self.conv1(x)) 
    ...:         return F.relu(self.conv2(x)) 
    ...:                                                                                                                                                                                                            

In [18]: real = realex()                                                                                                                                                                                            

In [19]: real                                                                                                                                                                                                       
Out[19]: 
realex(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace)
    (3): Dropout(p=0.5)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
  (conv1): Conv1d(1, 20, kernel_size=(5,), stride=(1,))
  (conv2): Conv2d(20, 20, kernel_size=(6, 6), stride=(1, 1))
)

In [20]: class realex(nn.Module): 
    ...:     def __init__(self): 
    ...:         super().__init__() 
    ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
    ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
    ...:     def forward(self, x): 
    ...:         x = F.relu(self.conv1(x)) 
    ...:         return F.relu(self.conv2(x)) 
    ...:                                                                                                                                                                                                            

In [21]: real = realex()                                                                                                                                                                                            

In [22]: real                                                                                                                                                                                                       
Out[22]: 
realex(
  (conv1): Conv1d(1, 20, kernel_size=(5,), stride=(1,))
  (conv2): Conv2d(20, 20, kernel_size=(6, 6), stride=(1, 1))
)

In [23]: nn.Module?                                                                                                                                                                                                 
Init signature: nn.Module()
Docstring:     
Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing to nest them in
a tree structure. You can assign the submodules as regular attributes::

    import torch.nn as nn
    import torch.nn.functional as F

    class Model(nn.Module):
        def __init__(self):
            super(Model, self).__init__()
            self.conv1 = nn.Conv2d(1, 20, 5)
            self.conv2 = nn.Conv2d(20, 20, 5)

        def forward(self, x):
           x = F.relu(self.conv1(x))
           return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will have their
parameters converted too when you call :meth:`to`, etc.
File:           ~/anaconda3/lib/python3.6/site-packages/torch/nn/modules/module.py
Type:           type

In [24]: os.system('vim ~/anaconda3/lib/python3.6/site-packages/torch/nn/modules/module.py')                                                                                                                        
Out[24]: 0

In [25]: class realex(nn.Module): 
    ...:     def __init__(self): 
    ...:         super().__init__() 
    ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
    ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
    ...:     def forward(self, x): 
    ...:         x = F.relu(self.conv1(x)) 
    ...:         return x 
    ...:                                                                                                                                                                                                            

In [26]: real = realex()                                                                                                                                                                                            

In [27]: real                                                                                                                                                                                                       
Out[27]: 
realex(
  (conv1): Conv1d(1, 20, kernel_size=(5,), stride=(1,))
  (conv2): Conv2d(20, 20, kernel_size=(6, 6), stride=(1, 1))
)

In [28]: class realex(nn.Module): 
    ...:     def __init__(self): 
    ...:         super().__init__() 
    ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
    ...:         nn.ReLU(inplace=True) 
    ...:         nn.Dropout(inplace=True) 
    ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
    ...:     def forward(self, x): 
    ...:         x = F.relu(self.conv1(x)) 
    ...:         return x 
    ...:                                                                                                                                                                                                            

In [29]: rea = realex()                                                                                                                                                                                             

In [30]: rea                                                                                                                                                                                                        
Out[30]: 
realex(
  (conv1): Conv1d(1, 20, kernel_size=(5,), stride=(1,))
  (conv2): Conv2d(20, 20, kernel_size=(6, 6), stride=(1, 1))
)

In [31]: class realex(nn.Module): 
    ...:     def __init__(self): 
    ...:         super().__init__() 
    ...:         self.conv1 = nn.Conv1d(1, 20, 5) 
    ...:         self.relu = nn.ReLU(inplace=True) 
    ...:         nn.Dropout(inplace=True) 
    ...:         self.conv2 = nn.Conv2d(20, 20, 6) 
    ...:     def forward(self, x): 
    ...:         x = F.relu(self.conv1(x)) 
    ...:         return x 
    ...:                                                                                                                                                                                                            

In [32]: rea = realex()                                                                                                                                                                                             

In [33]: rea                                                                                                                                                                                                        
Out[33]: 
realex(
  (conv1): Conv1d(1, 20, kernel_size=(5,), stride=(1,))
  (relu): ReLU(inplace)
  (conv2): Conv2d(20, 20, kernel_size=(6, 6), stride=(1, 1))
)
yjinyyzyq
关注
专栏目录
系统学习Pytorch笔记三：Pytorch数据读取机制(DataLoader)与图像预处理模块(transforms)
Miracle8070
04-17 6万+
Pytorch官方英文文档：https://pytorch.org/docs/stable/torch.html? Pytorch中文文档：https://pytorch-cn.readthedocs.io/zh/latest/ 1. 写在前面 疫情在家的这段时间，想系统的学习一遍Pytorch基础知识，因为我发现虽然直接Pytorch实战上手比较快，但是关于一些内部的原理知识其实并不是太懂，这样...
TypeError: forward() takes 2 positional arguments but 4 were given
weixin_48331187的博客
09-11 2702
这个错误是由于`model_PFNet.py`文件中的`forward`方法定义不正确导致的。根据错误信息，`forward`方法接受了2个位置参数，但实际传递了4个参数。要解决这个问题，你需要检查`model_PFNet.py`文件中的`forward`方法的定义，并确保它接受正确的参数数量。你可以根据实际情况调整`forward`方法的定义来适配传递的参数数量，并确保调用时提供正确的参数。
Python基础八 函数（上）
zjw3542的博客
12-14 1646
1.函数简介 函数是一个对象 函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用 语法格式： def 函数名称(形式参数): """函数的功能说明""" （缩进） 代码块 return[expression] 创建函数的规则 （1）函数代码块以def关键词开头，后接函数标识名称和圆括号() （2）传入的参数和自变量放于圆括号中间 （3）函数的第一行语句最好写上注释用于说明函数的功能 （4）return关键词既是一个返回值的关键词也是标志函数结束的标识符 （5）如
【Python报错已解决】“TypeError: forward() takes 2 positional arguments but 3 were given”
最新发布
鸽芷咕的博客
09-04 943
在深度学习框架如PyTorch中定义和使用自定义网络时，我们可能会遇到这样一个错误信息：“TypeError: forward() takes 2 positional arguments but 3 were given”。这个错误表明我们尝试调用一个方法时，传递的参数数量不正确。在PyTorch中，自定义网络的`forward`方法通常只接受两个参数：`self`和`x`，其中`self`是指向网络实例的引用，`x`是输入数据。如果我们的项目需要用到自定义网络，并且`forward`方法定义不正确，那么
TypeError: __init__() takes 3 positional arguments but 4 were given
everysigleday的博客
11-09 4941
报错。
onnx踩坑记录
zhang2362167998的博客
03-28 1206
TypeError: forward() takes 2 positional arguments but 3 were given ONNX export of operator adaptive pooling, since output_size is not constant Exporting the operator grid_sampler to ONNX opset version 13 is not supported. RuntimeError: view size is not co
python的重写问题，TypeError: C.__init__() takes 3 positional arguments but 4 were given
jdrtiffany的博客
11-18 966
python重写的TypeError: C.__init__() takes 3 positional arguments but 4 were given
B站整理的pytorch笔记
05-21
"PyTorch基础知识点" PyTorch是当前深度学习领域中最流行的框架之一，广泛应用于计算机视觉、自然语言处理、语音识别等领域。以下是对PyTorch基础知识点的总结。 torch.tensor：PyTorch中的基本数据结构是tensor，...
深度学习之千字pytorch笔记
06-08
以上就是这个文件的基本描述，这个pytorch笔记耗时好几天才完成的，大家可以根据自己的需求去取决于要不要下载哈。最后我希望这个笔记可以帮助到大家，去解决大家所存在的实际问题，或者能让大家更深入地了解和认识...
Pytorch笔记.pdf
07-20
PyTorch是一个开源的机器学习和深度学习框架，它广泛应用于研究和生产环境中，特别是在计算机视觉和自然语言处理领域。PyTorch的开发始于2016年，由Facebook的人工智能研究团队推动。它允许研究人员和开发者构建动态...
【Pytorch】成功解决TypeError: forward() takes 2 positional arguments but 3 were given
创作高质量博文，分享知识，共同进步！
04-05 6867
🌟【Pytorch进阶】告别TypeError，轻松掌握forward方法调用🔍 遇到`TypeError: forward() takes 2 positional arguments but 3 were given`错误时，你是否感到头疼不已？😖别担心，本文带你深入理解错误原因，精准定位问题源头，并提供实用解决方法！🛠️从nn.Module到forward方法，我们将一起探索PyTorch的奥秘，让你在实战中轻松避免此类错误。🌱此外，我们还将分享提升技术视野的秘诀，助你成为PyTorch高
深度学习中训练时候遇到这些错误 RuntimeError、IndexError、ValueError如何解决
m0_63669388的博客
07-17 4826
RuntimeError: Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same CUDA error: device-side assert triggeredRuntimeError: Expected all tensors to be on the same device, The size of tensor a (5) must match the size of
TypeError: forward() takes 2 positional arguments but 5 were given
m0_50140251的博客
02-24 1520
TypeError: forward() takes 2 positional arguments but 5 were given
typeError: __call__() takes 2 positional arguments but 3 were given
qq_43477055的博客
11-10 3151
typeError: call() takes 2 positional arguments but 3 were given@TOC在运行python程序中出现了参数个数报错的原因。 原因： 1、类中定义的函数未设置参数self; 2、已经初始化了一个与类名相同的函数，因此再调用类时，调用了该函数而非类你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。我们对Markdown编辑器进行
python selenium出现TypeError: __init__() takes 2 positional arguments but 3 were given错误解决方法
热门推荐
learning......
12-12 1万+
在使用selenium爬取时, 如出现以下错误: TypeError: __init__() takes 2 positional arguments but 3 were given 很有可能你的如下语句有问题: ec.presence_of_element_located(By.ID, 'feed_friend') **注意⚠️presence_of_element_located()方法中传...
刘二大人pytorch笔记
05-01
很高兴为您介绍刘二大人的PyTorch笔记，他是国内知名的深度学习技术专家，在PyTorch领域也有着非常深厚的技术功底和经验。以下是他的PyTorch笔记： 1. PyTorch基础入门 - PyTorch简介 - PyTorch基础数据类型 - PyTorch自动求导机制 2. PyTorch高级进阶 - PyTorch数据加载和处理 - PyTorch模型构建和调试 - PyTorch训练技巧和优化 3. PyTorch实战应用 - PyTorch图像分类任务 - PyTorch自然语言处理任务 - PyTorch目标检测和分割任务 以上是刘二大人的PyTorch笔记大纲，如果您对PyTorch有兴趣，可以参考这些笔记进行学习。如果您有其他问题，也可以继续向我提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值