1、PIL读取图像转成tensor
pil_img = Image.open(img_path)
array = np.asarray(pil_img)
data = t.from_numpy(array)2、读取路径，得到文件名
1）遍历文件夹，得到想要的文件名
img_path = self.imgs[index]
# dog->1， cat->0
label = 1 if 'dog' in img_path.split('/')[-1] else 0
imgs = os.listdir(root)
# 所有图片的绝对路径
# 这里不实际加载图片，只是指定路径，当调用__getitem__时才会真正读图片
self.imgs = [os.path.join(root, img) for img in imgs] def __init__(self, root, transforms=None, train=True, test=False):
"""
主要目标： 获取所有图片的地址，并根据训练，验证，测试划分数据
"""
self.test = test
imgs = [os.path.join(root, img) for img in os.listdir(root)]
# test1: data/test1/8973.jpg
# train: data/train/cat.10004.jpg
# imgs:['data/test1/8973.jpg', 'data/test1/8974.jpg', 'data/test1/8975.jpg', 'data/test1/8976.jpg']
if self.test:
imgs = sorted(imgs, key=lambda x: int(x.split('.')[-2].split('/')[-1]))
else:
imgs = sorted(imgs, key=lambda x: int(x.split('.')[-2]))
imgs_num = len(imgs)2）另外一个例子：遍历所有文件的名字，随机划分训练集合验证集。
读取换行的文件名，记得去除空格：
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
def main():
random.seed(0) # 设置随机种子，保证随机结果可复现
#所有图片名字格式： 2007_00000027.jpg
files_path = "./VOCdevkit/VOC2012/Annotations"
assert os.path.exists(files_path), "path: '{}' does not exist.".format(files_path)
val_rate = 0.5
files_name = sorted([file.split(".")[0] for file in os.listdir(files_path)])
files_num = len(files_name)
val_index = random.sample(range(0, files_num), k=int(files_num*val_rate))
train_files = []
val_files = []
for index, file_name in enumerate(files_name):
if index in val_index:
val_files.append(file_name)
else:
train_files.append(file_name)
try:
train_f = open("train.txt", "x")
eval_f = open("val.txt", "x")
train_f.write("\n".join(train_files))
eval_f.write("\n".join(val_files))
except FileExistsError as e:
print(e)
exit(1)3、PyTorch提供了torchvision。
它是一个视觉工具包，提供了很多视觉图像处理的工具，其中transforms模块提供了对PIL Image对象和Tensor对象的常用操作。
对PIL Image的操作包括：
Scale：调整图片尺寸，长宽比保持不变CenterCrop、RandomCrop、RandomResizedCrop： 裁剪图片Pad：填充ToTensor：将PIL Image对象转成Tensor，会自动将[0, 255]归一化至[0, 1]
对Tensor的操作包括：
- Normalize：标准化，即减均值，除以标准差
- ToPILImage：将Tensor转为PIL Image对象
Compose函数拼接多个操作，如下：
from PIL import Image
import numpy as np
from torchvision import transforms as T
transform = T.Compose([
T.Resize(224), # 缩放图片(Image)，保持长宽比不变，最短边为224像素
T.CenterCrop(224), # 从图片中间切出224*224的图片
T.ToTensor(), # 将图片(Image)转成Tensor，归一化至[0, 1]
T.Normalize(mean=[.5, .5, .5], std=[.5, .5, .5]) # 标准化至[-1, 1]，规定均值和标准差
])
4、torchvision.io ：read_image
this function allows to read an image and directly load it as a tensor.允许读取图像并将其作为张量直接加载。
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import torch
import torchvision.transforms as T
from torchvision.io import read_image
plt.rcParams["savefig.bbox"] = 'tight'
torch.manual_seed(1)
def show(imgs):
fix, axs = plt.subplots(ncols=len(imgs), squeeze=False)
for i, img in enumerate(imgs):
img = T.ToPILImage()(img.to('cpu'))
axs[0, i].imshow(np.asarray(img))
axs[0, i].set(xticklabels=[], yticklabels=[], xticks=[], yticks=[])
dog1 = read_image(str(Path('assets') / 'dog1.jpg'))
dog2 = read_image(str(Path('assets') / 'dog2.jpg'))
show([dog1, dog2])5、torchvision.transforms中的图像预处理代码
from torchvision import models, transforms
# 迁移学习，预训练模型
net = models.resnet18(pretrained=True)
# 标准化
normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
# 数据转换
image_transform = transforms.Compose([
# 将输入图片resize成统一尺寸
transforms.Resize([224, 224]),
# 随机裁剪(随机大小，随机宽高比）并调整至指定大小
T.RandomReSizedCrop(224),
# 随机水平翻转
T.RandomHorizontalFlip(),
# 将PIL Image或numpy.ndarray转换为tensor，并除255归一化到[0,1]之间
transforms.ToTensor(),
# 标准化处理-->转换为标准正太分布，使模型更容易收敛
normalize
])6、zip压缩函数使用：
将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
enumerate() 枚举函数：用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# training and plot
for epoch in range(Epoch):
for step, (b_x, b_y) in enumerate(loader):
for net,opt,l_his in zip(nets,optimizers,losses_his):
output = net(b_x)
loss=criterion(output,b_y)
opt.zero_grad()
loss.backward()
opt.step()
l_his.append(loss.data.numpy())
if step%25 == 1 and epoch%7==0:
labels = ['SGD', 'Momentum', 'RMSprop', 'Adam','Adagrad']
for i, l_his in enumerate(losses_his):
plt.plot(l_his, label=labels[i])
plt.legend(loc='best')
plt.xlabel('Steps')
plt.ylabel('Loss')
plt.ylim((0, 0.2))
plt.xlim((0, 200))
print('epoch: {}/{},steps:{}/{}'.format(epoch+1,Epoch,step*Batch_size,len(loader.dataset)))
plt.show()
7、指定范围，随机填充tensor
torch.empty(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False)
根据给定形状和类型,返回一个包含未经初始化数据的张量.
random_(from=0, to=None, *, generator=None) → Tensor
用一个离散均匀分布[from, to - 1]来填充当前自身张量.
import torch
loss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True)
input
Out[12]:
tensor([[-0.1153, -1.0817, 2.5642, 0.5169, -0.3778],
[-1.3685, 1.6164, 1.3879, -0.1657, 0.4537],
[ 0.6512, 0.2624, 0.5835, 0.1809, 0.8777]], requires_grad=True)
target = torch.empty(3, dtype=torch.long).random_(5)# 指定范围
target
Out[14]: tensor([1, 3, 0])
output = loss(input, target)
output.backward()
output
Out[17]: tensor(2.6730, grad_fn=<NllLossBackward0>)torch.linspace(start, end, steps=100, out=None) → Tensor
返回一个1维张量，包含在区间start和end上均匀间隔的step个点。
输出张量的长度由steps决定。这个有时会用到取plot横坐标。
torch.linspace(3, 10, steps=5)
3.0000
4.7500
6.5000
8.2500
10.0000
[torch.FloatTensor of size 5]8、批量更改文件名、修改图片大小
由于参考代码训练的是32X32图片，而且图片名字也是标签名+序号，所以我们想要直接用的话，就必须做修改工作。
分为:rename、resize两个步骤。
#coding=utf-8
from PIL import Image
import os
import os.path
import glob
def rename(rename_path,outer_path,folderlist):
#列举文件夹
for folder in folderlist:
if os.path.basename(folder)=='bus':
foldnum = 0
elif os.path.basename(folder)=='taxi':
foldnum = 1
elif os.path.basename(folder)=='truck':
foldnum = 2
elif os.path.basename(folder)=='family sedan':
foldnum = 3
elif os.path.basename(folder)=='minibus':
foldnum = 4
elif os.path.basename(folder)=='jeep':
foldnum = 5
elif os.path.basename(folder)=='SUV':
foldnum = 6
elif os.path.basename(folder)=='heavy truck':
foldnum = 7
elif os.path.basename(folder)=='racing car':
foldnum = 8
elif os.path.basename(folder)=='fire engine':
foldnum = 9
inner_path = os.path.join(outer_path, folder)
total_num_folder = len(folderlist) #文件夹的总数
# print 'total have %d folders' % (total_num_folder) #打印文件夹的总数
filelist = os.listdir(inner_path) #列举图片
i = 0
for item in filelist:
total_num_file = len(filelist) #单个文件夹内图片的总数
if item.endswith('.jpg'):
src = os.path.join(os.path.abspath(inner_path), item) #原图的地址
dst = os.path.join(os.path.abspath(rename_path), str(foldnum) + '_' + str(i) + '.jpg') #新图的地址（这里可以把str(folder) + '_' + str(i) + '.jpg'改成你想改的名称）
try:
os.rename(src, dst)
# print 'converting %s to %s ...' % (src, dst)
i += 1
except:
continue
#训练集
rename_path1 = 'E:/Tensorflow-CNN-VehicleIdentification/renametrain'
outer_path1 = 'E:/Tensorflow-CNN-VehicleIdentification/train'
folderlist1 = os.listdir(r"E:/Tensorflow-CNN-VehicleIdentification/train")
rename(rename_path1,outer_path1,folderlist1)
print("train totally rename ! ! !")
#测试集
rename_path2 = 'E:/Tensorflow-CNN-VehicleIdentification/renametest'
outer_path2 = 'E:/Tensorflow-CNN-VehicleIdentification/val'
folderlist2 = os.listdir(r"E:/Tensorflow-CNN-VehicleIdentification/val")
rename(rename_path2,outer_path2,folderlist2)
print("test totally rename ! ! !")
#修改图片尺寸
def convertjpg(jpgfile,outdir,width=32,height=32):
img=Image.open(jpgfile)
img=img.convert('RGB')
img.save(os.path.join(outdir,os.path.basename(jpgfile)))
new_img=img.resize((width,height),Image.BILINEAR)
new_img.save(os.path.join(outdir,os.path.basename(jpgfile)))
#训练集
for jpgfile in glob.glob("E:/Tensorflow-CNN-VehicleIdentification/renametrain/*.jpg"):
convertjpg(jpgfile,"E:/Tensorflow-CNN-VehicleIdentification/data")
print("train totally resize ! ! !")
#测试集
for jpgfile in glob.glob("E:/Tensorflow-CNN-VehicleIdentification/renametest/*.jpg"):
convertjpg(jpgfile,"E:/Tensorflow-CNN-VehicleIdentification/test")
print("test totally resize ! ! !")9、查看python包的版本
1.方法一 通过命令行
pip list 或 conda list中有相应的包名和版本号
pip show 包名
pip show numpy
2.方法二
通过程序
import numpy
print(numpy.__version__)
3. 查看python版本
命令行中输入python
命令行 python --version
（配置好环境变量的前提下）
10、在python的List中使用for循环语句的技巧汇编
参考文章：《在python的List中使用for循环语句的技巧汇编_-派神-的博客-CSDN博客_list for》
1) 简单替换for循环
它的主要语法结构如下：
my_list=[ 表达式 for 循环项 in 循环体 (if 条件) ]
这里表达式可以为循环项，也可以为循环项的函数或者方法，下面我们看给例子：
name = "Donald Trump"
#list内的for循环语法,只使用一句代码
my_list = [c for c in name]
print(name)
print(my_list)
2)在list内的循环中使用if 条件
names_list = ["Washington", "Trump", "Obama", "bush", "Clinton", "Reagan"]
l1 = [name for name in names_list if name.startswith('W')]
l2 = [name for name in names_list if name.startswith('W') or len(name) < 5]
l3 = [name for name in names_list if len(name) < 5 and name.islower()]
print(l1, l2, l3)
3) 使用更加复杂的表达式
names_list = ["washington", "trump", "obama", "bush", "clinton", "reagan"]
#将人名首字母大写
new_names = [name.capitalize() for name in names_list]
print(new_names)
这里我们list内的表达式使用了循环项name的方法capitalize(), 我们再看一个例子：
my_list=[ 表达式(if...else 条件) for 循环项 in 循环体 ]
names_list = ["Washington", "Trump", "Obama", "bush", "Clinton", "Reagan"]
#在表达式中使用if条件
new_names = [name if name.startswith('T') else 'Not President' for name in names_list]
print(new_names)之前我们是在for循环的尾部添加if 条件，不过我们也可以在表达式中使用if条件语句。这里需要指出的是表达式内的if条件语句中必须要同时使用else语句，这和之前在for循环尾部添加if条件有所不同，这是因为在表达式内的if语句必须遵循给变量赋值的python语法.
4)尽量使用生成器(Generator)变量来减少内存开销
在python中定义一个list变量时，一般会给这个list变量立即分配内存,这种在定义变量时立即分配内存的方式会增加系统的内存开销，而一种高效的方法是只在定义变量时并不立即分配实际内存,只在真正使用变量时才会分配内存，这就是我们的Generator变量，在定义Generator变量时只要将原来list的方括号替换成圆括号即可：
#list变量,立即分配实际内存
L1 = [x for x in range(1_000_000)]
#Generator变量,不分配实际内存
L2 = (x for x in range(1_000_000))
print(L1.__sizeof__())
print(L2.__sizeof__()) 
#list变量
L1 = [ w for w in range(10)]
for i in L1:
print(i)
#替换为生成器变量
L2 = (w for w in range(10))
for i in L2:
print(i)11、Python中文件的open,close,read,write等操作
1）字文本值，可以这样操作。f.readlines()返回的是列表，可以直接用for循环解析 。
f = open('test.txt', 'r')
content = f.readlines() #读取文件中的全部行，按行划分存储到列表中，类型字符串
print(type(content)) #打印读取结果的值类型，用list列表存储
i=1 #遍历列表，将读取的内容显示出来，按照原来文件的行划分。
for temp in content:
print("%d:%s"%(i, temp))
i+=1
f.close()
参考网址：Python中文件的open,close,read,write等操作_涤生大数据的博客-CSDN博客
读取换行的文件名，记得去除空格：
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
with open(txt_path) as read:
xml_list = [os.path.join(self.annotations_root, line.strip() + ".xml")
for line in read.readlines() if len(line.strip()) > 0]
2）Python如何读取二进制文件，并解析。
def xshow(filename, nx, nz):
# 我们需要给定二进制数据的行数列数（nx和ny）来确定图像的形状
f = open(filename, "rb")
pic = np.zeros((nx, nz))
for i in range(nx):
for j in range(nz):
data = f.read(4)
# 使用 struct 模块中的 unpack() 函数将二进制转化为十进制的float32型
elem, = struct.unpack("f", data)
pic[i][j] = elem
f.close()
return pic
参考文章：
1、使用Python读取二进制文件的实例讲解 - 杰米工坊 更新日期：2022/11/20
3、Python读取二进制文件代码方法解析_程序猿中的BUG的博客-CSDN博客
12、python中字符串的join()函数的用法
分隔符，后面可以接- 列表，元组，字符串，字典和集合，它将可迭代的每个元素（如列表，字符串和元组）连接到字符串，并返回连接后的字符串。
str="abcd"
print("_".join(str))运行结果：
13、指定数据类型申请list和tupe
这是 Python 3.5 中引入的 Type Annotation，是一种注解，用来提示变量的类型。其中
var为要定义的变量；type为该变量期待的类型；value为赋给该变量的值。
a: int = 10
def func(arg: int)
# 第一种
original_image_sizes = torch.jit.annotate(list[tuple[int, int]], [])
a = [1,2]
b = [3,4]
original_image_sizes.append((a,b))
# 第二种
original:list[tuple[int, int]] = []
original.append((a,b))
14、Pycharm的Python Console终端清除命令
Pycharm的Python Console 清除单个变量命令：
del 变量名称Pycharm的Python Console 清除所有变量命令：
reset -fPycharm的Python Console 清屏：
右击鼠标，选择clear。
15、torch.as_tensor()、torch.Tensor() 、 torch.tensor() 、transforms.ToTensor()的区别
详细情况参考我这篇文章《torch.as_tensor()、torch.Tensor() 、 torch.tensor() 、transforms.ToTensor()的区别_三世的博客-CSDN博客》
1）torch.as_tensor(data, dtype=None,device=None)->Tensor : 为data生成tensor，浅拷贝。
如果data已经是tensor或ndarray，且dtype和device与参数相同，则生成的tensor会和data共享内存（浅拷贝）。
#1)数据类型和device相同，浅拷贝，共享内存
import numpy
a = numpy.array([1, 2, 3])
t = torch.as_tensor(a)
t[0] = -12) torch.tensor() 是一个通过深拷贝数据，构造一个新张量的函数：
torch.tensor(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False) →Tensor
重点是data的数据类型can be a list, tuple, NumPy ndarray, scalar, and other types，就没waring。
但data是tensor类型，使用torch.tensor(data)就会报waring
#没警告：data can be a list, tuple, NumPy ndarray, scalar, and other types
import torch
import numpy
a = numpy.array([1, 2, 3])
t = torch.tensor(a)
b = [1,2,3]
t= torch.tensor(b)
c = (1,2,3)
t= torch.tensor(c)
#data是tensor类型，有警告
#data是tensor类型，有警告
import torch
import numpy
d = torch.tensor([[1,2,3],[1,2,3]])
t= torch.tensor(d) #能深拷贝，但会报warning，建议用t = a.clone().detach()
# detach是内存共享的，而clone()是不内存共享的。
print(d.shape,d.dtype,t.shape,t.dtype)
# torch.Size([2, 3]) torch.int64 torch.Size([2, 3]) torch.int643）torch.Tensor() 是默认张量类型 (torch.FloatTensor()) 的别名。也就是说，torch.Tensor() 的作用实际上跟 torch.FloatTensor() 一样。
4)transforms.ToTensor()
ToTensor()将shape为(H, W, C)的nump.ndarray或img转为shape为(C, H, W)的tensor，其将每一个数值归一化到[0,1]，其归一化方法比较简单。
在transforms.Compose([transforms.ToTensor()])中加入transforms.Normalize()，如上面代码所示：则其作用就是先将输入归一化到(0,1)，再使用公式"(x-mean)/std"，将每个元素分布到(-1,1)。
16、Python 列表list详解（超详细）
参考这篇文章《Python 列表list详解（超详细）_LeoATLiang的博客-CSDN博客_python的list》
17、python学习--DataFrame，可以分组统计 groupby
参考这篇文章《python学习--DataFrame_悠闲的小鱼Liu的博客-CSDN博客_python dataframe》
18、 Python 更新字典的三种形式（update()）
>>> d = {
... 'title': 'Python Web Site',
... 'url': 'http://www.python.org'
... }
>>> x = [('title', 'Python Language Website')]
>>> d.update(x)
>>> d
{'url': 'http://www.python.org', 'title': 'Python Language Website'}参考这篇文章《Python 更新字典的三种形式_梦因you而美的博客-CSDN博客_python 字典 更新》
19、Python中Tuple（元组的单引号）
Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义。比如t=(1)，被误解为申请了一个int型变量t =1：
>>> t = (1,)
>>> print t
(1,)
参考这篇文章《Python中Tuple（元组）_码上寒山石径斜的博客-CSDN博客_python tuple》
20、Python中的isinstance()函数：
1）判断一个函数是否是一个已知的类型，多个类型的话，第二个参数用一个元组代替。
a = 2
isinstance(a,int) # 结果返回 True
isinstance(a,str) # 结果返回 False
isinstance(a,(str,int,list)) # 是元组中的一个类型 int，结果返回 True2）与type()函数的区别是:
- isinstance() 会认为子类是一种父类类型，考虑继承关系。
- type() 不会认为子类是一种父类类型，不考虑继承关系。
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False参考这篇文章《Python中的isinstance()函数_DaYinYi的博客-CSDN博客_python isinstance》
21、python中如何使用None增加数据维度
import torch
x = torch.randint(4,(1, 4)) # torch.Size([1, 4])
print(x)
# 增加第一维度
a = x[None, :, :] # torch.Size([1, 1, 4])
# 也是增加了第一维度
b = x[None] # torch.Size([1, 1, 4])
# 增加第三维度
c = x[:,:,None] # torch.Size([1, 4, 1])参考文章：
《Pytorch中用None增加Tensor维度_打呼噜的星.的博客-CSDN博客_pytorch 添加维度》
《python中如何使用None增加数据维度_月下花弄影的博客-CSDN博客》
再举个例子《Fast R-CNN》里的代码：
def normalize(self, image):
"""标准化处理"""
dtype, device = image.dtype, image.device
mean = torch.as_tensor(self.image_mean, dtype=dtype, device=device)
std = torch.as_tensor(self.image_std, dtype=dtype, device=device)
# [:, None, None]: shape [3] -> [3, 1, 1]
return (image - mean[:, None, None]) / std[:, None, None]写个case验证一下。
import torch
image = torch.rand((10,3,2))
mean =[0.1]*10
std = [0.5]*10
mean = torch.as_tensor(mean)
std = torch.as_tensor(std)
m = (image-mean[:,None,None]) /std[:,None,None] #image的shape是C*H*W，mean和std只是一个维度，所以要增加两个维度，才能计算。22、pytorch之torch.unbind()函数
移除指定维后，返回一个元组，包含了沿着指定维切片后的各个切片。
import torch
t = torch.rand(3,3) #随机生成一个tensor
print(t)
print(t.shape)
r = torch.unbind(t,dim=0)#dim = 0指定拆除的维度
print(r)
s = torch.unbind(t,dim=1)#dim = 1指定拆除的维度
print(s)结果：
参考文章《pytorch之torch.unbind - 飞猪流 - 博客园》
23、torch.stack()函数
stack 将tensor进行按照指定维度进行堆叠，函数返回的结果会新增一个维度。
dim = 0时，将tensor1和tensor2进行堆叠；
dim = 1时，将tensor1[0]和tensor2[0]进行堆叠；
dim = 2时，将tensor1[0][0]和tensor2[0][0]进行堆叠；
import torch
w = torch.arange(12).reshape(3, 4)
h = -torch.arange(12).reshape(3, 4)
c = torch.stack((w, h), dim=0)
>>>
tensor([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[ 0, -1, -2, -3],
[ -4, -5, -6, -7],
[ -8, -9, -10, -11]]])
>>> c.shape
>torch.Size([2, 3, 4])
-----------------------------------------------
b = torch.stack((w, h), dim=1)
>>>
tensor([[[ 0, 1, 2, 3],
[ 0, -1, -2, -3]],
[[ 4, 5, 6, 7],
[ -4, -5, -6, -7]],
[[ 8, 9, 10, 11],
[ -8, -9, -10, -11]]])
>>>b.shape
>torch.Size([3, 2, 4])
-----------------------------------------------
d = torch.stack((w, h), dim=2)
print(d)
print(d.shape)
>>>
tensor([[[ 0, 0],
[ 1, -1],
[ 2, -2],
[ 3, -3]],
[[ 4, -4],
[ 5, -5],
[ 6, -6],
[ 7, -7]],
[[ 8, -8],
[ 9, -9],
[ 10, -10],
[ 11, -11]]])
torch.Size([3, 4, 2])
参考文章：
《torch.stack()函数_小娜美要努力努力的博客-CSDN博客_torch.stack() 》
《torch.stack()用法_打呼噜的星.的博客-CSDN博客_torch.stack()》
24、【torch.Tensor.new_full】详解
用新值，填充新建tensor和原先tensor形状一样
import torch
ten = torch.ones((2,), dtype=torch.float64)
new_ten=ten.new_full((3, 4), 3.141592)
print(new_ten.dtype,new_ten.device,new_ten.requires_grad)
print(new_ten)
参考文章《【torch.Tensor.new_full】详解_panbaoran913的博客-CSDN博客_new_full》
25、zip()可以用for循环并行迭代
1）zip()返回的是zip对象，可以通过list()转换成list查看，也可以通过dict()转换成字典查看
a = ["a","c","e","g"]
b = ["b","d","f","h"]
print("这是一个列表\n",list(zip(a,b))) #转换成列表
print("这是一个字典\n",dict(zip(a,b))) #转换成字典2）每个迭代器的元素个数不一致，则返回的列表长度与最短的一致。
3）zip()可以用for循环并行迭代
a = [1,2,3,4,5]
b = [5,4,3,2,6]
c = zip(a,b)
for a, b in c:
print(a,"*",b,"=",a*b)结果：
4）与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
a = [1,2,3,4,5]
b = ["d","b","e","r"]
c = zip(*(zip(a,b)))
print(list(c))结果：
参考文章：《Python内置函数zip()的用法 - 小白白学Python - 博客园》
26、torch.copy_()函数进行tensor的复制。
Tensor.copy_(src, non_blocking=False) → Tensor
定义：Copies the elements from src into self tensor and returns self.
1）若采用直接赋值的方式，原来权重的存储指针会指向新得到的权重张量的存储区域；而使用 .copy_() 的话，仅仅是改变原来权重的值，存储区域则不发生改变。copy_()有利于降低运算。
import torch
x = torch.tensor([[1,2], [3,4], [5,6]])
y = torch.rand((3,2)) # [0,1)之间均匀分布
print(y,id(y))
y = x #赋值操作，导致y的地址指向变了
print(y,id(y))import torch
x = torch.tensor([[1,2], [3,4], [5,6]])
y = torch.rand((3,2)) # [0,1)之间均匀分布
print(y,id(y))
y.copy_(x) # copy_()操作，y的地址指向没变，只是重新赋值。
print(y,id(y))2）指定区域拷贝
import torch
x = torch.tensor([[1,2], [3,4], [5,6]])
z = torch.rand((4,2))
z[:x.shape[0],:x.shape[1]].copy_(x) #只拷贝x的大小区域
print(z[:x.shape[0],:x.shape[1]].copy_(x))
print(z)参考文章
《【Pytorch 模型训练 Issue】tensor.copy_() 与 直接赋值(=) 对训练耗时的影响 - 知乎》
《torch.copy_()函数介绍_三世的博客-CSDN博客》
27、Python官方的copy操作： 直接赋值、浅拷贝和深度拷贝解析
-
直接赋值：其实就是对象的引用（别名）。
-
浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
-
深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
-
列表切片等价于深复制 比如：list1 = [1,2,[3,4]] list2 = list1[:]
参考文章：
《python 模块 copy 复制详解_ghostwritten的博客-CSDN博客_python copy》
《Python 直接赋值、浅拷贝和深度拷贝解析 | 菜鸟教程》
28、torch.nn.init常用函数总结
- torch.nn.init.uniform_(tensor, a=0.0, b=1.0)：按均匀分布U ( a , b ) U(a,b)U(a,b)对tensor随机赋值。
- torch.nn.init.normal_(tensor, mean=0.0, std=1.0) ：按正态分布N ( μ 或 mean , σ 或 std ) N(\mu或mean,\sigma或std)N(μ或mean,σ或std)对tensor随机赋值。
- torch.nn.init.constant_(tensor, val)：使用常数
val对tensor赋值。
# 使用nn.init.constant_对参数赋值
nn.init.constant_(self.linear.weight, 0.2) - torch.nn.init.ones_(tensor) ：使用常数
1对tensor赋值。 - torch.nn.init.zeros_(tensor)：使用常数
0对tensor赋值。 - torch.nn.init.eye_(tensor) ：使用常数
1对tensor的主对角线进行赋值，其余位置为常数0。 - torch.nn.init.sparse_(tensor, sparsity, std=0.01) ：生成稀疏矩阵。
sparsity ：每列中需要被设置成零的元素比例，std ：用于生成的正态分布的标准差。
参考文章《torch.nn.init常用函数总结_不牌不改的博客-CSDN博客_torch.nn.init.normal_》
29、pytorch中stack（）函数和cat（）函数的区别
pytorch框架其中stack（）函数和cat（）函数都是将两个输入组合成一个batch.
1）stack函数
二者的区别在于，stack（）函数是将两个输入堆叠起来，维度会增加1。
import torch
x = torch.rand((2,3))
y = torch.rand((2,3))
z = torch.stack((x,y),dim=0)这样两个堆叠起来的 z 的维度是（2，2，3），相当于在dim=0将二者堆叠起来，第一个数字2就是增加的维度。输出结果：
2）cat函数
而cat（）函数是将两个输入在现有维度上叠加起来，不改变维度数量。
import torch
x1 = torch.rand((2,3))
y1 = torch.rand((2,3))
z1 = torch.cat((x1,y1),dim=0)这样两个叠加起来的 z1 的维度是（2，3），相当于在dim=0将二者叠加起来，不改变输入的维度。结果输出：
30、Pytorch的tensor基本操作
参考文章《Pytorch的tensor基本操作_Swayzzu的博客-CSDN博客_pytorch tensor》
30、torch.split()用法
torch.split(tensor, split_size_or_sections, dim=0)
torch.split()作用将tensor分成块结构。
1）split_size_or_sections为int型时
import torch
x = torch.rand(4,8,6)
y = torch.split(x,2,dim=0) #按照4这个维度去分，每大块包含2个小块
for i in y :
print(i.size())
output:
torch.Size([2, 8, 6])
torch.Size([2, 8, 6])2）split_size_or_sections为list型时。
import torch
x = torch.rand(4,8,6)
y = torch.split(x,[2,3,3],dim=1)
for i in y:
print(i.size())
output:
torch.Size([4, 2, 6])
torch.Size([4, 3, 6])
torch.Size([4, 3, 6])
9515
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
