Pytorch官方文档个人阅读总结

Pytorch之nn.Conv1d学习个人见解 Pytorch之nn.Conv1d学习个人见解 一、官方文档(务必先耐心阅读) 官方文档:点击打开《CONV1D》 二、Conv1d个人见解 Conv1d类构成 class torch.nn.Conv1d(in_channels, out_channels, kernel_size,stride=1, padding=0, dilation=1, groups=1, bias=True) in_channels(int)—输入数据的通道数。在文本分类中,即为句子中单个词的词向量的维度。 (word_vec 阅读详情

原文官方文档tutor:https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html

1. Introduction

1.1 数据载入

1.1.1 预加载的数据集

pytorch的默认库TorchText、TorchVision、TorchAudio都提供了默认的数据集;链接如下—

PyTorch domain libraries provide a number of pre-loaded datasets (such as FashionMNIST) that subclass torch.utils.data.Dataset and implement function specific to the particular data. They can be used to prototype and benchmark your model. You can find them here: Image Datasets, Text Datasets, and Audio Datasets

1.1.2 数据加载

数据载入部分提供了datasets和DataLoader:将原始的PILImage格式或者numpy.array格式的数据格式化为可被pytorch快速处理的张量类型

  • Dataset存储了样本和标签,
  • DataLoader包装迭代器(相当于列表可以通过 t e s t [ 0 ] [ 0 ] 、 t e s t [ 0 ] [ 1 ] test[0][0]、test[0][1] test[0][0]、test[0][1]取值)通过这个函数我们在准备加载数据集使用mini-batch的时候可以使用多线程并行处理,这样可以加快我们准备数据集的速度。Datasets就是构建这个工具函数的实例参数之一。

参数说明

  • root is the path where the train/test data is stored,
  • train specifies training or test dataset,
  • transform and specify the feature and label transformationstarget_transform
from torch.utils.data import DataLoader
from torchvision import datasets
# Every TorchVision Dataset includes two arguments:
#transform and target_transform to modify the samples and labels respectively.
training_data=datasets.FashionMNIST(
    root="../data",
    train=True,
    download=True,
    transform=ToTensor(),
)
test_data=datasets.FashionMNIST(
    root="../data",
    train=False,
    download=True,
    transform=ToTensor(),
)
batch_size = 64

# 2.Create data loaders.
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

for images, labels in train_dataset_loader:
    # 将数据传给网络模型 

注意通道在第2位,N, C, H, W

for X, y in test_dataloader:
    print(f"Shape of X [N, C, H, W]: {X.shape}")
    print(f"Shape of y: {y.shape} {y.dtype}")
    break

1.1.3 模型数据可视化

figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
    for i in range(1, cols * rows + 1):
    sample_idx = torch.randint(len(training_data), size=(1,)).item()
    img, label = training_data[sample_idx] 
    figure.add_subplot(rows, cols, i)
    plt.title(labels_map[label]) #提前设置的映射关系
    plt.axis("off")
    plt.imshow(img.squeeze(), cmap="gray")
plt.show()

1.1.4 制作数据集

详细可查看

  • class CustomImageDataset(Dataset):

  • 必须实现三个函数: init, len, and getitem

class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None)
    :初始化包含图像、注释文件和两种转换的目录
    
    def __len__(self): function returns the number of samples in our dataset
    def __getitem__(self, idx):从 csv 数据中检索相应的标签,调用它们上面的转换字典,并返回在 tuple.

怎么结合transforms操作生成数据集

import torch.nn.functional as F
import torch
import torch 
import torch.nn as nn
from torch.autograd import Variable
import torchvision.models as models
from torchvision import transforms, utils
from torch.utils.data import Dataset, DataLoader
from PIL import Image
import numpy as np
import torch.optim as optim
import os
#torch.cuda.set_device(gpu_id)#使用GPU
learning_rate = 0.0001
#数据集的设置*****************************************************************************************************************
root =os.getcwd()+ '/data1/'#调用图像

#定义读取文件的格式
def default_loader(path):
    return Image.open(path).convert('RGB')

#首先继承上面的dataset类。然后在__init__()方法中得到图像的路径,然后将图像路径组成一个数组,这样在__getitim__()中就可以直接读取:
class MyDataset(Dataset): #创建自己的类:MyDataset,这个类是继承的torch.utils.data.Dataset
	def __init__(self,txt, transform=None,target_transform=None, loader=default_loader): #初始化一些需要传入的参数
		super(MyDataset,self).__init__()#对继承自父类的属性进行初始化
		fh = open(txt, 'r')#按照传入的路径和txt文本参数,打开这个文本,并读取内容
		imgs = []
		for line in fh: #迭代该列表#按行循环txt文本中的内
			line = line.strip('\n')
			line = line.rstrip('\n')
            # 删除 本行string 字符串末尾的指定字符,这个方法的详细介绍自己查询python
			words = line.split()
            #用split将该行分割成列表  split的默认参数是空格,所以不传递任何参数时分割空格
			imgs.append((words[0],int(words[1]))) 
            #把txt里的内容读入imgs列表保存,具体是words几要看txt内容而定 
        # 很显然,根据我刚才截图所示txt的内容,words[0]是图片信息,words[1]是lable       
		self.imgs = imgs
		self.transform = transform
		self.target_transform = target_transform
		self.loader = loader        
        
	def __getitem__(self, index):#这个方法是必须要有的,用于按照索引读取每个元素的具体内容
		fn, label = self.imgs[index] #fn是图片path #fn和label分别获得imgs[index]也即是刚才每行中word[0]和word[1]的信息
		img = self.loader(fn) # 按照路径读取图片
		if self.transform is not None:
			img = self.transform(img) #数据标签转换为Tensor
		return img,label#return回哪些内容,那么我们在训练时循环读取每个batch时,就能获得哪些内容
	
    def __len__(self): #它返回的是数据集的长度,也就是多少张图片,要和loader的长度作区分
		return len(self.imgs)
 #根据自己定义的那个MyDataset来创建数据集!注意是数据集!而不是loader迭代器


#*************数据集读取完毕**************
#图像的初始化操作
train_transforms = transforms.Compose([
    transforms.RandomResizedCrop((227,227)),
    transforms.ToTensor(),
])
text_transforms = transforms.Compose([
    transforms.RandomResizedCrop((227,227)),
    transforms.ToTensor(),
])

#数据集加载方式设置
train_data=MyDataset(txt=root+'train.txt', transform=transforms.ToTensor())
test_data = MyDataset(txt=root+'text.txt', transform=transforms.ToTensor())

#或者直接拼接数据集
all_data=train_data+test_data

#然后就是调用DataLoader和刚刚创建的数据集,来创建dataloader,这里提一句,loader的长度是有多少个batch,所以和batch_size有关
train_loader = DataLoader(dataset=train_data, batch_size=6, shuffle=True,num_workers=4)
test_loader = DataLoader(dataset=test_data, batch_size=6, shuffle=False,num_workers=4)
print('num_of_trainData:', len(train_data))
print('num_of_testData:', len(test_data))

  • getitem还可以这样写

     # 返回idx的数据和当前图片的label
     def __getitem__(self,idx):
         # idex-[0-总长度]
         # retrun images,labels
         # 将图片,label的路径取出来
         # 得到的img是这样的一个类型:'pokeman\\bulbasaur\\00000000.png'
         # 然而label得到的则是 0,1,2 这样的整形的格式
         img,label=self.images[idx],self.labels[idx]
         tf=transforms.Compose([
             lambda x:Image.open(x).convert('RGB'),  # 将t图片的路径转换可以处理图片数据
             # 进行数据加强
             transforms.Resize((int(self.resize*1.25),int(self.resize*1.25))),
             # 随机旋转
             transforms.RandomRotation(15),   # 设置旋转的度数小一些,否则的话会增加网络的学习难度
             # 中心裁剪
             transforms.CenterCrop(self.resize),   # 此时:既旋转了又不至于导致图片变得比较的复杂
             transforms.ToTensor(),
             transforms.Normalize(mean=[0.485,0.456,0.406],
             std=[0.229,0.224,0.225])
        ])
    

1.1.5 图像增强&ToTensor

区分PIL、OpenCV、Totensor

P I L 图 像 在 n p . a r r a y ( i m a g e , d t y p e = n p . f l o a t 32 ) 转 换 为 n u m p y . n d a r r a y 后 , 格 式 为 ( h , w , c ) , 像 素 顺 序 为 R G B ; O p e n C V 在 c v 2. i m r e a d ( ) 后 数 据 类 型 为 n u m p y . n d a r r a y , 格 式 为 ( h , w , c ) , 像 素 顺 序 为 B G R 。 PIL图像在 np.array(image,dtype=np.float32)转换为numpy.ndarray后,\\格式为(h,w,c),像素顺序为RGB;\\ OpenCV在cv2.imread()后数据类型为numpy.ndarray,\\格式为(h,w,c),像素顺序为BGR。 PIL图像在np.array(image,dtype=np.float32)转换为numpy.ndarray后,格式为(h,w,c),像素顺序为RGB;OpenCV在cv2.imread()后数据类型为numpy.ndarray,格式为(h,w,c),像素顺序为BGR。

  1. torchvision.transforms: 常用的图像操作,例如:随机切割,旋转,数据类型转换,

  2. torchvision.transforms.ToTensor():
    如:FashionMNIST 为PIL 图像格式,标签是整数。

    对于训练,我们需要将特征作为归一化张量,and scales the image’s pixel intensity values in the range [0., 1.]。为了进行这些转换,我们使用 ToTensor 和 Lambda

    从to_tensor()函数看到,函数接受PIL Image或numpy.ndarray,将其先由HWC转置为CHW格式,再转为float后每个像素除以255.0

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DXOe1zHl-1650183834034)(pytorch/image-20220212155314169.png)]

实例

ToTensor converts a PIL image or NumPy ndarray into a FloatTensor.
首先创建一个大小为 10 的零张量(我们数据集中的标签数量)并调用 scatter_,它在标签 y 给定的索引上分配 value=1。

#图像到tensor ,numpy 数组到tensor , tensor 到图像等
ds = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor(),
        target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))

API

1.2 定义模型

1.2.1 定义模型

class NeuralNetwork(nn.Module):#继承nn.Module;nn.Module的子类在forward()函数中实现对输入数据的操作
    def __init__(self):
    def forward(self, x): #只需要直接输入model(X);不需要直接调用model.forward()
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10)
        )

        def forward(self, x):
            x = self.flatten(x)
            logits = self.linear_relu_stack(x)
            return logits

1.2.2 模型的层次:

  • nn.Flatten:保留通道信息

    convert each 3D 3x28x28 image into a contiguous array of 3x784 pixel values

  • nn.Linear:nn.Linear(in_features=28*28, out_features=20)

  • nn.Sequential:

    模块的有序容器 You can use sequential containers to put together a quick network like seq_modules.

  • nn.Softmax:
    softmax = nn.Softmax(dim=1)
    pred_probab = softmax(logits)

    ​ #logits 是一个向量,下一步被投给 softmax操作

神经网络的最后一个线性层返回logits -原始值[-inf, inf] -这些值被传递给神经网络。
Softmax模块,logits被缩放为值[0,1],表示模型对每个类的预测概率。Dim参数表示值之和必须为1的维度

1.2.3 模型参数

获取模型参数:
nn.Module 自动跟踪模型对象中定义的所有字段,
并使用模型的 parameters() 或 named_parameters() 方法使所有参数都可以访问。

print("Model structure: ", model, "\n\n")
for name, param in model.named_parameters():
print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

1.2.4 获取GPU:

  1. 获取设备:

    device = "cuda" if torch.cuda.is_available() else "cpu"
    
  2. 将模型放入GPU:

    model = NeuralNetwork().to(device)
    

1.3 定义损失和优化

损失函数:注意区分softmax和交叉熵,softmax只是特例

loss_fn=nn.CrossEntropyLoss()#多分类的交叉熵

优化器:我们通过注册需要训练的模型参数,并传入学习率超参数来初始化优化器。torch.optim.

 optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

在训练循环中,优化分三个步骤进行:

这三个函数的作用是先将梯度归零(optimizer.zero_grad()),然后反向传播计算得到每个参数的梯度值(loss.backward()),最后通过梯度下降执行一步参数更新(optimizer.step())

  1. 调用 optiizer.zero_grad()重置模型参数的梯度。缺省情况下,梯度是累加的; 为了防止重复计算,我们在每次迭代时显式地将它们归零。
  2. 通过调用loss.backward()反向传播预测损失
  3. 一旦我们有了梯度,我们就调用 optimizer.step()来通过在后向传递中收集的梯度来调整参数

1.4 模型训练、测试、预测:

  • 训练:在训练函数加了model.train()
    ​ model.train() #启动batch normalization和dropout

  • 测试和预测加上:
    ​ model.eval()

    ​ 神经网络沿用batch normalization,不再使用dropout
    ​ with torch.no_grad():此是不会对w等系数求导

1.4.1 训练

def train(dataloader,model,loss_fn,optimizer):
    size=len(dataloader.dataset)
    model.train() #启动batch normalization和drop out
    for batch,(X,y) in enumerate(dataloader):
        X,y=X.to(device),y.to(device)
        pred=model(X)
        loss=loss_fn(pred,y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch % 100==0:
            loss,current=loss.item(),batch*len(X)
            print(f'loss:{loss:>7f}[{current:>5d}/{size:>5d}]')

1.4.2 验证

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

epochs = 5
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model, loss_fn)
print("Done!")

1.4.3 预测

// 预测
classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]
model.eval()
x,y=test_data[0][0],test_data[0][1]
with torch.no_grad():
model.eval()
x, y = test_data[0][0], test_data[0][1]
with torch.no_grad():
    pred = model(x)
    predicted, actual = classes[pred[0].argmax(0)], classes[y]
    print(f'Predicted: "{predicted}", Actual: "{actual}"')

1.5 保存模型

  1. 将模型序列化:保存模型参数
    PyTorch models store the learned parameters in an internal state dictionary, called state_dict

    torch.save(model.state_dict(), "model.pth")     
    
  2. 加载模型:重新创建模型和加载状态字典

    model = NeuralNetwork()     
    model.load_state_dict(torch.load("model.pth"))
    
  3. 跳过参数直接保存模型参数和结构并加载:这种方法在序列化模型时使用 Python pickle 模块,因此它依赖于在加载模型时可用的实际类定义。

    本质上还是需要引入参数

     torch.save(model, 'model.pth')
     model = torch.load('model.pth')
    

1.6 Tensor

1.6.1 基本属性和申请GPU

默认设备是cpu:
Tensor的属性里面有device和dtype

申请GPU

if torch.cuda.is_available():   
tensor=tensor.to('cuda')

1.6.2 其他操作:

  • 切片操作:tensor[:,1]=0

  • cat: concatenate a sequence of tensors along a given dimension.

    t1 = torch.cat([tensor, tensor, tensor], dim=1) # 列上相加
    
  • 点乘:

    print(f"tensor.mul(tensor) \n {tensor.mul(tensor)} \n")
    print(f"tensor * tensor \n {tensor * tensor}")
    
  • 矩阵乘法:

    print(f"tensor.matmul(tensor.T) \n {tensor.matmul(tensor.T)} \n")
    print(f"tensor @ tensor.T \n {tensor @ tensor.T}")
    
  • 就地操作:可以节约内存;具有_后缀的操作为就地操作。

    x.copy_(y), x.t_() #改变x
    print(tensor, "\n")
    tensor.add_(5)
    

    x.copy_(y) # 将y的内容复制到tensor中并返回这个tensor位x

  • 节省内存:+=

    before = id(X)
    X += Y
    id(X) == before
    

1.6.3 和numpy的桥梁:

此时tensor和Numpy array都在CPU,共享内存地址相同改变

  • tensor->numpy:

    t = torch.ones(5)
    print(f"t: {t}")
    n =t.numpy()
    print(f"n: {n}")
    # t的改变t会改变n
    t.add_(1) 
    print(f"t: {t}")
    print(f"n: {n}")     
    
  • numpy->tensor:

    n = np.ones(5)
    t = torch.from_numpy(n)
    #同样因为共享内存改变了NUmpy会改变tensor
    np.add(n, 1, out=n)
    print(f"t: {t}")
    print(f"n: {n}")
    

1.7 Torch.autograd

1.7.1 torch.autograd

为计算梯度,PyTorch的一个内置的区分引擎 。torch.autograd支持任意计算图的梯度自动计算。

requires_grad 属性支持梯度计算;可以在创建张量时设置

x = torch.ones(5)  # input tensor
y = torch.zeros(3)  # expected output
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w)+b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)

loss.grad_fn:我们用来构造计算图的张量函数实际上是类函数的对象。这个对象知道如何向前计算函数,以及如何在向后传播步骤中计算函数的导数。

print('Gradient function for w =', w.grad_fn)

1.7.2 loss.backward()

为了计算这些导数,我们调用loss.backward(),然后从 w.grad 和 b.grad 中检索值:

loss.backward()
print(w.grad)
#tensor([[0.1022, 0.2449, 0.2776],
#        [0.1022, 0.2449, 0.2776],
#        [0.1022, 0.2449, 0.2776],
#        [0.1022, 0.2449, 0.2776],
#        [0.1022, 0.2449, 0.2776]])
print(b.grad)#tensor([0.1022, 0.2449, 0.2776])
  • 出于性能方面的考虑,我们只能在给定的图上使用向后一次的梯度计算。如果我们需要对同一个图执行多个向后调用,我们需要将 retain_graph = True 传递给向后调用。

    假如你需要执行两次backward,先执行第一个的backward,再执行第二个backward

    loss1.backward(retain_graph=True)# 这里参数表明保留
    loss2.backward() 
    

    #backward后的中间参数。不加那么计算图x-y-z结构就被释放了,需要retain_graph参数为True去保留中间参数从而两个loss的backward()不会相互影响。

    #执行完这个后,所有中间变量都会被释放,以便下一次的循环

    #如果是在训练网络用optimizer.step(),更新参数

  • 我们**只能得到计算图的叶子节点的梯度属性,这些叶子节点需要梯度属性设置为 True。**对于我们图中的所有其他节点,梯度将不可用。

1.7.3 禁用梯度更新

所有带 require _ grad = True 的张量都将跟踪它们的计算历史和支持梯度计算。

  1. 禁用是预先训练的网络进行微调的一个非常常见的场景
  2. 禁用后只进行正向传递的情况下加快计算速度,因为在不跟踪梯度的张量上的计算将更加有效。

禁用的方式为了取消跟踪通过网络进行前向计算。我们可以通过:

  1. 法一:在计算代码周围加上torch.no_grad()来停止跟踪计算

    z = torch.matmul(x, w)+b
    print(z.requires_grad)         #true
    with torch.no_grad():
        z = torch.matmul(x, w)+b
        print(z.requires_grad)          #false
    
  2. 法二:在张量上使用 detach() 方法:

    z = torch.matmul(x, w)+b
    z_det = z.detach()
    print(z_det.requires_grad)
    

1.7.4.更多关于计算图:

  1. autograd 在一个由函数对象组成的有向无环图(DAG)中保存数据(张量)和所有执行的操作(以及由此产生的新张量)的记录。
  2. 在PyTorch中,DAG是动态的。在每次.backward()调用之后,autograd开始填充一个新的图。
    这正是允许你在模型中使用控制流语句的原因;如果需要,您可以在每次迭代中更改形状、大小和操作。
  3. 在向前传球时,autograd会同时做两件事:
    • 运行请求的操作来计算结果张量
    • 在DAG中保持操作的梯度函数。
  4. 当.backward ()被调用到 DAG 根目录. 向后传递就开始了:
    • 计算每个.grad_fn()的梯度,
    • 将它们累加到各自张量的.grad属性中
    • 利用链式法则,一直传播到叶张量。

注意,当我们使用相同的参数第二次向后调用时,梯度的值是不同的。这是因为在做反向传播时,PyTorch会对梯度进行累加,
即计算出的梯度的值被添加到计算图的所有叶子节点的grad属性中。如果你想计算正确的梯度,你需要在此之前将grad属性归零。

loss.zero_grad()

2. Dos

2.1 自动混合精度训练

结合torch.cuda.amp.autocast torch.cuda.amp.GradScaler 一起训练

2.1.1 autocast

对选定的区域进行autocast操作;

自动为GPU操作选择精度,在保持精度的同时提高性能。

2.1.2 GradScaler

prevent underflow(float16的值可能无法表示小幅度的梯度变化)

有助于方便地执行梯度缩放的步骤,梯度缩放通过最小化梯度下溢来改进具有梯度的网络的收敛性,保证梯度值具有较大的幅度,因此它们不会刷新为零

【代码阅读】详解在Pytorch中定义自己写的CUDA编程函数 文章目录Pointnet++函数的pytorch接口设置要点 目前,3D的网络,尤其时point-based的网络,很多模块在pytorch中都没有官方实现,这就需要我们自己写。例如PointNet++中的FPS,group,query等函数。之前也只是用过,对其的修改也限于python层面,这次,就好好探究一下,如何自定义一个函数,如何将其加入到pytorch中,使得在pytorch中也能用。 其实,这一块,有非常详细的官方文档,讲述了如何自定义一个函数,并将其放入Pytorch中。当然,如何写一个函数, 阅读详情

相关推荐

PyTorch安装、使用、学习指南

Abstract:PyTorch是一个python优先的非常优秀的深度学习框架,本文是个人总结的关于如何安装、使用和学习PyTorch的指南。 1.PYTORCH介绍Torch是一个科学计算框架,广泛支持机器学习算法,将GPU放在第一位。由于使用简单快速的脚本语言LuaJIT以及底层的C / CUDA实现,因此易于使用和高效。核心功能:一个强大的N维数组许多例行索引,切片,转置,...通过LuaJ...

ScarlettYellow的博客 3595

Pytorch 官方文档教程整理 (一)

pytorch官网tutorial学习整理 中文教程

qq_53580131的博客 6030

PyTorch中文文档.md

PyTorch中文文档,内容全面,干货满满,初学者必备

Pytorch英文官方文档学习笔记(一、Tensors)

Pytorch英文官方文档学习

m0_50364811的博客 1389

传统芯片封装工艺流程简介

塑封是将工件和树脂安装在模具中,加热模具,使树脂液化充满模具,降温保持一定时间后,树脂凝结为固态即可取出。它将一个大的晶圆切割成许多单独的小块,每个小块是一个“芯片”(Chip,die),这些芯片是单个集成电路的基本单位。对裸露在外的引线框架外脚电镀Sn-Pb合金,这样不仅可以提高外脚的抗氧化性,还有利于后续与印刷电路板的焊接。导电胶粘贴法:将含有银粉的环氧树脂(银浆)涂敷在框架或基板上,再将芯片放置其上,固化后可以将芯片牢牢粘接。引线框架的各腿是用筋连接着的,起支撑作用,塑封固化后,需要将其连筋切掉。

芯想是陈的博客 3194

计算机视觉——多视图几何

多视图几何1.前言1.1 多视图几何概念2. 基本原理2.1 对极几何2.2 基础矩阵2.2.1 基础矩阵推导2.2.2 求解基础矩阵3. 实验过程3.1 实验数据准备3.2 实验代码3.3 实验结果及分析4. 实验中遇到的问题 1.前言 1.1 多视图几何概念 多视图几何是利用在不同视点所拍摄图像间的关系,来研究照相机之间或者特征之间关系的一门科学。 多视图几何(Multiple View ...

RuiMa的博客 7715

PyTorch官方教程(中文版)

2023PyTorch官方教程中文版(附加自己的解释)

weixin_40433846的博客 1万+

UE5网络模块实战:属性复制、RPC与联机开发踩坑指南

多人联机开发中,网络同步是核心难题。UE5网络模块以服务器权威为基础,通过Actor复制、RPC和所有权机制实现多端状态一致。理解属性复制与OnRep回调、区分Server/Client/Multicast RPC的适用场景,是构建稳定联机架构的关键。本文结合数字孪生与多端协作场景,探讨如何将渲染与逻辑分离,并针对打包后网络失效、端口防火墙、崩溃排查等工程实践问题给出解决方案。通过蓝图接口解耦表现层,利用C++创建StaticMesh组件实现服务器逻辑与客户端表现分离,同时注意专用服务器不加载渲染依赖(如D

weixin_29010003的博客 274

学习历程笔记(二)pytorch官方文档学习笔记

nn.Linear:用于定义模型的线性层,完成前面提到的线性转换,参数有(输入特征数,输出特征数、是否使用偏置(默认为true)),会自动生成对应维度的权重参数和偏置。中的一种序列容器,通过在容器中嵌套各种实现神经网络中具体功能相关的类,来完成对神经网络模型的搭建;-在每次训练模型迭代过程中,模型对输出进行猜测,计算猜测和实际标签的误差,收集误差关于其参数的导数,并使用梯度下降优化这些参数。使用梯度下降算法来更新模型参数,在该算法中,需要计算损失函数关于模型参数的梯度,这个计算过程就是反向传播算法。

这里是萤石ym的学习路途,努力搬砖! 617

手把手教你接入京东购物小程序:从领券到下单的全流程解析

本文详细解析了如何从API申请到领券下单,手把手教你接入京东购物小程序的全流程。涵盖京东联盟账号注册、商品信息获取、优惠券链接转换等关键技术实践,帮助开发者高效实现电商功能集成,提升用户购物体验。

g5h6i的博客 912

【鼠标在不点击的情况下,直接移动到QT控件上不显示提示信息】

有时明明已经调用了setToolTips方法,鼠标移动到QT控件上仍然不会有提示信息,这时候就需要具体分析下。重点就是标红的这段话,大概意思就是。.h文件中加入鼠标移动事件的定义。.cpp文件中实现该事件。

ZTH_G的博客 2427

【Pytorch】Pytorch官方文档

Pytorch官方文档中文链接:

码农努力学习 1904

深度学习——VGG16模型详解

1、网络结构 VGG16模型很好的适用于分类和定位任务,其名称来自牛津大学几何组(Visual Geometry Group)的缩写。 根据卷积核的大小核卷积层数,VGG共有6种配置,分别为A、A-LRN、B、C、D、E,其中D和E两种是最为常用的VGG16和VGG19。 介绍结构图: conv3-64 :是指第三层卷积后维度变成64,同样地,conv3-128指的是第三层卷积后维度变成128; input(224x224 RGB image) :指的是输入图片大小为224244的彩色图像,通道为

橙子的博客 12万+

重装CUDA和cuDNN(目的是装TensorFlow和pytorch)【个人梳理总结】

以下是本人在学习过程中,在自己有限的阅读和学习后总结的重装/安装 CUDA、cuDNN、tensorflow和pytorch的框架式(流程式)经验。 阅读完我的总结,你可以了解“到哪儿”,“找什么”,“什么顺序”以及“有哪些地方”等收获,同时也会留下很多自己在阅读官方文档和指引中的疑问帮助自己日后精进。

WarnerJDoe的博客 3388

基于libVLC的视频播放器之四:直接使用libVLC

一.效果 播放本地文件 播放网络url:rtsp://3.84.6.190/vod/mp4:BigBuckBunny_115k.mov 二.实现 既然有VLC-Qt,为什么还要直接调用libVLC呢,因为直接调用会加深对整个播放流程的理解,方便后面修改VLC-Qt源码。 注意事项: 1.编译报错:error C2065: “libvlc_media_read_cb”: 未声明的标识符。修改如下: 2.libvlc_new(0, nullptr)返回null 将plugins

草上爬的博客 5051

GPU硬件架构与微架构深度解析09-GPU寄存器文件深度解析

本文探讨GPU架构中大规模寄存器堆的设计与高效分配算法。寄存器文件作为GPU关键组件,支持大规模线程并行和快速数据存取。文章分析了多体寄存器堆的设计考量,包括端口数量、冲突避免和功耗管理,并比较了线性扫描、图着色等寄存器分配算法的特点。还介绍了寄存器压缩、动态分区等高级优化技术,以及NVIDIA Ampere架构的实际案例。这些技术对提升GPU计算性能和能效至关重要。

2301_79143213的博客 122

如何阅读PyTorch文档及常见PyTorch错误

如何阅读PyTorch文档及常见PyTorch错误

欢迎来到三水编程的博客 1401

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

如何有效地阅读PyTorch的源代码?

就像一位优秀的厨师不会仅仅满足于按照食谱做菜,而是会亲自走进厨房,尝试不同的调料搭配一样,真正想精通 PyTorch 的开发者也应该勇敢地打开它的“引擎盖”,看看里面到底藏着什么秘密。的数据分析师来说,参与这样的社区活动不仅有助于提高技术水平,还能为未来的认证考试积累宝贵的经验。按照之前的建议,我们的第一步应该是查阅官方文档,了解该类的基本用法以及参数含义。事实上,它们往往是最好的参考资料之一。无论你是刚刚接触 PyTorch 的新手,还是已经有一定经验的开发者,相信这篇文章都能给你带来新的启发。

cda2024的博客 1077

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

小土堆--pytorch--官方文档阅读

我对应python面向对象的语法不是很了解,所以阅读文档很困难,后面应该专门学习一下这方面的知识。

打工人。。 265

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

【pytorch官方文档学习之二】tensors

本系列旨在通过阅读官方pytorch代码熟悉CNN各个框架的实现方式和流程。 【pytorch官方文档学习之一】tensors 本文是对官方文档PyTorch: Tensors的详细注释和个人理解,欢迎交流。 tensor 与 numpy的区别 Behind the scenes, Tensors can keep track of a computational graph and gradients, but they’re also useful as a generic tool for scie

youzhizhe2014的博客 187

PyTorch 源码学习①:阅读经验 & 代码结构

分享关于 PyTorch 源码阅读经验和 PyTorch 代码结构的资料。

weixin_43254181的博客 2527

如何阅读pytorch框架的源码?

他们官方网站的教程也是非常不错的参考,可以看看官方提供的教程,跑一下github上提供的demo。他们官方网站的教程也是非常不错的参考,可以看看官方提供的教程,跑一下github上提供的demo。有一定的了解,一般选择Ubuntu系统作为主力系统,了解一下基础的系统命令就可以了,比如rm,ls,cd,cat,vim,sudo,find,df,top等,在B站上搜索一下Linux的视频,很快就可以入门。,吴恩达的深度学习课还有斯坦福大学的CS231n都是不错的入门教程,只需要有大学数学的基础就可以看懂。

m0_57290404的博客 404

Pytorch实战:基于pytorch预测文章阅读量

介绍 这里用简单的网络来预测优快云的阅读量。 我希望训练后的模型,给它前7天的阅读量,让它预测出第八天的阅读量。 阅读量的数据(很少)采用优快云提供的excel文件: 这里采用xrld工具包来读取文件。 def get_readings(): book = xlrd.open_workbook('./data/article_readings.xlsx') sheet1 = book.sheet_by_name('sheet1') # excel中一个文件有多个表格,因为数据量小,所

m0_52733659的博客 1112

从PyTorch官方文档高效获取信息的技巧分享

面对PyTorch环境配置难题,预构建的PyTorch-CUDA镜像成为高效解决方案。掌握如何从官方文档和镜像设计中快速提取关键信息,理解Jupyter与SSH的使用场景、端口映射逻辑及安全规范,能显著提升开发效率。通过结构化思维分析容器层级关系,精准定位问题并建立标准化工作流,是实现AI工程化落地的关键。

weixin_35903223的博客 990
上一篇: 计算机视觉期末复习(上)
下一篇: 计算机视觉期末复习(中)
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值