Pytorch tutorial pytorch 入门

基于PyTorch的深度学习入门教程_Neural_Networks_tutorial 摘要 ''' Neural Networks = = = = = = = = = = = = = = = 神经网络可以用'torch.nn'包构建。现在您已经大致了解了'autograd','nn'依赖于'autograd'来定义模型并区分它们。 一个"nn.Module"包含层,以及一个方法' ' forward(input) ' ' 它返回“输出”。 例如,看看这个分类数字图像的网络:... 阅读详情

今天看了pytorch官方的tutorial,好美的教程哦,说是60min的闪电战,结果运行完代码,花了一整天,是我不配,网站官方地址是:https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html

这篇tutorial主要分为四个部分:

1、什么是Tensor,和Tensorflow介绍差不多

2、自动求梯度(微分)

3、神经网络架构

4、以一个图像分类作为example实战

 

1、WHAT IS PYTORCH?

是一个基于python的科学计算包,有两个作用

【1】取代numpy,而且可以在GPU 上运行

【2】一个提供了最大灵活性和速度的深度学习研究平台

我的目的肯定是2,才不会为了取代numpy安装torch

1.1 Tensor construction

关于torch有这么记过方法来生成特殊的Tensor(矩阵)

torch.empty(2,3,4)生成一个参数size的矩阵,值为原内存值
torch.rand(2,3,4)随机值生成一个矩阵
zeros(2,3,4)所有元素都为0
ones(2,3,4)所有元素为1
eye(2,2)对角矩阵
tensor([8,2,8])生成值为【8,2,8】的Tensor,指定值

randn_like(a)

ones_like(a)

zeros_like(a)

..._like(a)

值为'_'前面的属性,比如随机,属性和参数a一致,除非指明

 

 

 

 

 

 

 

 

 

Tesor.size()返回的是元组,支持所有的元组操作

1.2 Tensor Operation

【1】加:x+y  或 torch.add(x,y,out=res)  或   y.add_(x)  等价于y+=x 

任何改变张量对象的操作都有“_”    e.g.  x.copy_(y)    x.t_()

【2】切片 :x[ : , 1 ]

【3】reshape/resize:y=x.view(16)    y=x.view(-1,8)

【4】当tensor只有一个元素,可以使用a.item()来调用这个值 

【5】z=a.mean()

【6】求范式:a.norm(p='fro'),fro是2范式

【7】x.eg(y) 判断两个是否相等

【8】y=x.detach() 防止被追踪

tensor操作一个标量时,比如a+1、a*2,tensor里的每个元素都会进行该操作

 

 

1.3 NumPy Bridge(类型转换)

如果Torch的Tensor在CPU上运行,则Tensor和Numpy互相转化的变量共享一片内存

 

tensor (a) -------------a.numpy()--------------->  numpy(b)

tensor (a) <------tensor.from_numpy(b)-------  numpy(b)

 

2、AUTOGRAD: AUTOMATIC DIFFERENTIATION

听到长名词很高级,其实不然,不就是微分吗?pytorch的中心包就是autograd库,提供了tensor中所有操作的自动微分

重点:如果你设置tensor对象的.requires_grad属性为True【a.requires_grad_=True】,就开始追踪其上所有操作,当完成所有计算之后,你可以调用.backward()来自动计算所有的梯度,tensor的梯度会自动累加到.grad属性上

可以使用x.detach()防止梯度被追踪

也可以把代码加入 with torch.no_grad: ,可以在评估模型使用这种模式,因为评估时不需要计算梯度,y=x.detach()是获的一个有相同值但是不需要梯度的新的tensor,

有一个库 torch.Function,教程里说它和Tensor构成了一个有向无环图,我开始不理解,后面做笔记才理清,表示和存储了完整的计算历史,Tensor有个.grad_fn属性,它是引用创建tensor对象的那个Funcation,(除非这个张量是用户手动创建的,即,这个张量的 grad_fn 是 None)

tensor.backward()自动计算所有梯度,当其为标量时,就不用指定参数默认参数是out.backward(torch.tensor(1.)),假如不是,就需要指定梯度参数,维度要和tensor匹配,why?我是看的这篇文章理解的https://blog.csdn.net/sinat_28731575/article/details/90342082

https://zhuanlan.zhihu.com/p/33378444

在这里插入图片描述

这是官方文档,第一个参数tensor就是对象tensor,第二个参数就是我很好奇的参数了,假如不引用的话,会提示:

为什么在求导的过程中需要引入这个参数,如果我们不引入这个参数的话,则会报下面的错误:

RuntimeError: grad can be implicitly created only for scalar outputs

即为提示我们输出不是一个标量

因为我们平时调用这个函数都是对最后的loss进行backward,而这是一个标量,更普遍的是,它可以tensor对tensor进行backward:

注意:

pytoch构建的计算图是动态图,为了节约内存,所以每次一轮迭代完之后计算图就被在内存释放,所以当你想要多次backward时候就会报错,需要添加标识:retain_graph=True

loss.backward(retain_graph=True) # 添加retain_graph=True标识,让计算图不被立即释放
import torch
from torch.autograd import Variable # torch 中 Variable 模块

x = Variable(torch.FloatTensor([[1, 2]]), requires_grad=True)  # 定义一个输入变量
y = Variable(torch.FloatTensor([[3, 4],[5, 6]]))
loss = torch.mm(x, y)    # 变量之间的运算
loss.backward(torch.FloatTensor([[1, 0]]), retain_graph=True)  # 求梯度,保留图                                    
print(x.grad.data)   # 求出 x_1 的梯度

x.grad.data.zero_()  # 最后的梯度会累加到叶节点,所以叶节点清零
loss.backward(torch.FloatTensor([[0, 1]]), retain_graph=True)   # 求出 x_2的梯度
print(x.grad.data)        # 求出 x_2的梯度

x.grad.data.zero_()  # 最后的梯度会累加到叶节点,所以叶节点清零
loss.backward(torch.FloatTensor([[0, 2]]), retain_graph=True)   # 求出 x_2的梯度
print(x.grad.data)        # 求出 2*x_2的梯度

x.grad.data.zero_()  # 最后的梯度会累加到叶节点,所以叶节点清零
loss.backward(torch.FloatTensor([[1, 1]]), retain_graph=True)   # 求出 x_2的梯度
print(x.grad.data)        # 求出 x_2+x_2的梯度

输出:

理解:

最后的可以组成雅克比矩阵,与传入的参数相乘就可以了

作用:This characteristic of vector-Jacobian product makes it very convenient to feed external gradients into a model that has non-scalar output.

 

 

3、NEURAL NETWORKS

使用torch.nn可以构建神经网络,nn.Module类包含了许多层,以及forward()方法来返回输出

convnet

神经网络过程就不说了

  • Define the neural network that has some learnable parameters (or weights)
  • Iterate over a dataset of inputs
  • Process input through the network
  • Compute the loss (how far is the output from being correct)
  • Propagate gradients back into the network’s parameters
  • Update the weights of the network, typically using a simple update rule: weight= weight -learning_rate *gradient

 

三四章内容我就放一起讲了,我主要介绍我的代码,相比较于tutorial上的代码,有些调整。不仅包括了卷积层的kernel size

第一部分 引入的库/包

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

第二部分 网络定义

Conv2d(1,6,3):输入的channel大小为1,输出的channel为6,卷积核大小为3*3

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        #
        self.conv1=nn.Conv2d(3,6,3)

        self.pool=nn.MaxPool2d(2,2)
        self.conv2=nn.Conv2d(6,16,4)

        self.fc1=nn.Linear(16*6*6,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

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

        x=x.view(-1,self.num_flat_features(x))
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        return x


    def num_flat_features(self,x):
        y=x.size()[1:]
        s=1
        for i in y:
            s=s*i
        return s

定义的网路结构需要继承nn.Module,而且overide forward函数,backward()不需要重载,自动实现。学习到的参数都存储在net.parameters()

注意!torch.nn只支持mini-batch,不支持单个案例输入,举个例子,nn.Conv2d will take in a 4D Tensor of   nSamples x nChannels x Height x Width.假如是单个案例,可以通过input.unsqueeze(0)转化为一个batch sample

简要回顾:

  • torch.Tensor - A multi-dimensional array with support for autograd operations like backward(). Also holds the gradient w.r.t. the tensor.
  • nn.Module - Neural network module. Convenient way of encapsulating parameters, with helpers for moving them to GPU, exporting, loading, etc.
  • nn.Parameter - A kind of Tensor, that is automatically registered as a parameter when assigned as an attribute to a Module.
  • autograd.Function - Implements forward and backward definitions of an autograd operation. Every Tensor operation creates at least a single Function node that connects to functions that created a Tensor and encodes its history.

第三部分 损失函数:

损失函数将the (output, target) pair作为输入,记住output在前,有很多损失函数:https://pytorch.org/docs/stable/nn.html

定义损失函数和优化器

    criterion=nn.CrossEntropyLoss()
    optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

 

假如想得到输出的FN图,可以这样

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

 

第四部分 训练代码

反向传播前别忘了net.zero_grad() ,否则会累加

    
    net=Net()


    for epoch in range(5):
        running_loss=0.0
        running_acc=0.0
        for i,data in enumerate(trainloader,0):
            inputs,labels=data
            optimizer.zero_grad()
            output=net(inputs)
            _,pred=torch.max(output,1)
            loss=criterion(output,labels)
            loss.backward()
            optimizer.step()

            running_loss+=loss.item()
            running_acc+=torch.sum(pred==labels)

            if i%2000==1999:
                print('Epoch:{}:{} :loss={},acc={}'.format(
                    epoch+1,i+1,running_loss/2000,running_acc/12000))
                running_loss=0.0
                running_acc=0.0
    print("training is over")

有个torch.max函数,torch.max有两个参数:输入数组及比较的维度,输出有两个:第一个是结果,即该维度下最大的值是多少,第二个是最大值的索引

        x:
         tensor([[0.5285, 0.1247, 0.8332, 0.5485],
                [0.7917, 0.6138, 0.5881, 0.3381],
                [0.4226, 0.6605, 0.8571, 0.0399],
                [0.1716, 0.0609, 0.9712, 0.4838]])

        torch.max(x,1):
         (tensor([0.8332, 0.7917, 0.8571, 0.9712]), tensor([2, 0, 2, 2]))

第五部分 数据加载/处理:

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')


torchvision.transforms.Compose([传入一个数组]):通过compose将各个变换串联起来,参数是各个变换的实例对象
变换包括在PIL格式图片上的转换、torch.Tensor上的转换、类型转换:
1、剪切并返回中间区域、饱和度亮度对比度调整、灰度图、填充、旋转、裁剪等
2、对张量图像进行标准化处理Normalize(mean,std)
3、类型转换ToPILImage(mode=None)、ToTensor()参数可以是PIL或者是np.ndarray

DataLoader本质就是一个迭代对象,可以用iter()访问,不可以用next()访问,参数batch_size:每个batch的大小,每一次next()的数量就是batch_size大小
使用iter(DataLoader对象)返回的是一个迭代器,可以用next()访问
也可以使用for input,label in dataloaders:进行访问
num_workers表示用多少个线程处理data loading,默认为0,表示所有的数据都将load到主线程中

第六部分 测试代码:

def test_(testloader):
    PATH = './cifar_net.pth'
    net=Net()
    net.load_state_dict(torch.load(PATH))
    running_loss = 0.0
    running_acc = 0.0
    for i, data in enumerate(testloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        output = net(inputs)
        _, pred = torch.max(output, 1)
        loss = criterion(output, labels)

        running_loss += loss.item()
        running_acc += torch.sum(pred == labels)

        if i % 100 == 99:
            print('Epoch:{} :loss={},acc={}'.format(
                 i + 1, running_loss / 100, running_acc / 600))
            running_loss = 0.0
            running_acc = 0.0

 

完整代码:


import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np



class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        #
        self.conv1=nn.Conv2d(3,6,3)

        self.pool=nn.MaxPool2d(2,2)
        self.conv2=nn.Conv2d(6,16,4)

        self.fc1=nn.Linear(16*6*6,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

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

        x=x.view(-1,self.num_flat_features(x))
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        return x


    def num_flat_features(self,x):
        y=x.size()[1:]
        s=1
        for i in y:
            s=s*i
        return s

def imshow(img):
    img=img/2+0.5
    npimg=img.numpy()
    plt.imshow(np.transpose(npimg,(1,2,0)))
    plt.show()

'''
过程:
1、创建一个DataSet对象
2、创建一个DataLoader对象
3、循环这个DataLoader对象,并将data、label加载在模型中进行训练
'''

'''
torchvision.transforms.Compose([传入一个数组]):通过compose将各个变换串联起来
参数是各个变换的实例对象
变换包括在PIL格式图片上的转换、torch.Tensor上的转换、类型转换:
1、剪切并返回中间区域、饱和度亮度对比度调整、灰度图、填充、旋转、裁剪等
2、对张量图像进行标准化处理Normalize(mean,std)
3、类型转换ToPILImage(mode=None)、ToTensor()参数可以是PIL或者是np.ndarray
'''

transform=transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
trainset=torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
trainloader=torch.utils.data.DataLoader(trainset,batch_size=6,shuffle=True,num_workers=2)

'''
DataLoader本质就是一个迭代对象,可以用iter()访问,不可以用next()访问
batch_size:每个batch的大小,每一次next()的数量就是batch_size大小
使用iter(DataLoader对象)返回的是一个迭代器,可以用next()访问
也可以使用for input,label in dataloaders:进行访问
num_workers表示用多少个线程处理data loading,默认为0,表示所有的数据都将load到主线程中
'''
testset=torchvision.datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)
testloader=torch.utils.data.DataLoader(testset,batch_size=6,shuffle=True,num_workers=2)


str_class='plane car bird cat deer dog frog horse ship truck'
classes=str_class.split()


net=Net()
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

def test_(testloader):
    PATH = './cifar_net.pth'
    net=Net()
    net.load_state_dict(torch.load(PATH))
    running_loss = 0.0
    running_acc = 0.0
    for i, data in enumerate(testloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        output = net(inputs)
        _, pred = torch.max(output, 1)
        loss = criterion(output, labels)

        running_loss += loss.item()
        running_acc += torch.sum(pred == labels)

        if i % 100 == 99:
            print('Epoch:{} :loss={},acc={}'.format(
                 i + 1, running_loss / 100, running_acc / 600))
            running_loss = 0.0
            running_acc = 0.0

    '''
        torch.max有两个参数:输入数组及比较的维度,输出有两个:第一个是结果,即该维度下最大的值是多少,第二个是最大值的索引

        x:
         tensor([[0.5285, 0.1247, 0.8332, 0.5485],
                [0.7917, 0.6138, 0.5881, 0.3381],
                [0.4226, 0.6605, 0.8571, 0.0399],
                [0.1716, 0.0609, 0.9712, 0.4838]])

        torch.max(x,1):
         (tensor([0.8332, 0.7917, 0.8571, 0.9712]), tensor([2, 0, 2, 2]))
        '''
    #_,predicted=torch.max(outputs,1)
    #print("Predicted:", ",".join('%5s' % classes[predicted[j]] for j in range(6)))


if __name__ == '__main__':

    for epoch in range(5):
        running_loss=0.0
        running_acc=0.0
        for i,data in enumerate(trainloader,0):
            inputs,labels=data
            optimizer.zero_grad()
            output=net(inputs)
            _,pred=torch.max(output,1)
            loss=criterion(output,labels)
            loss.backward()
            optimizer.step()

            running_loss+=loss.item()
            running_acc+=torch.sum(pred==labels)

            if i%2000==1999:
                print('Epoch:{}:{} :loss={},acc={}'.format(
                    epoch+1,i+1,running_loss/2000,running_acc/12000))
                running_loss=0.0
                running_acc=0.0
    print("training is over")
    
    PATH='./cifar_net.pth'
    torch.save(net.state_dict(),PATH)

    test_(testloader)

 

[pytorch入门]神经网络tutorial教程笔记 代码来源https://github.com/yunjey/pytorch-tutorial,很好的教程。 linear_regression.py #linear_regression.py import torch import torch.nn as nn import numpy as np import matplotlib.pyplot as plt # Hyper-parameters input_size = 1 output_size = 1 num_epochs = 60 learn 阅读详情

相关推荐

基于PyTorch的深度学习入门教程_autograd_tutorial

摘要 Autograd:自动分化 PyTorch中所有神经网络的核心是“autograd”包。 让我们先简单地看一下这个,然后我们来训练我们的第一个神经网络。 “autograd”包为张量上的所有操作提供自动微分。它是一个按运行定义的框架,这意味着您的支持是由代码的运行方式定义的,并且每个迭代都可以是不同的。 让我们用更简单的术语和一些例子来看看。 张量 "torch.Tensor'"是...

hufei_neo的博客 542

PyTorch tutorials:快速学会使用PyTorch

PyTorch是由Facebook人工智能研究实验室(FAIR)开发的开源深度学习框架。它建立在Torch库之上,Torch是一个使用Lua编程语言的机器学习库。Torch主要用于研究和学术领域,而PyTorch则旨在为研究人员和实践者提供一个Python友好的接口。PyTorch是为灵活性和速度而设计的。它提供了一个名为Tensor的主要数据结构,用于存储和操作多维数组。Tensor类似于NumPy的ndarray,但可以利用GPU来加速计算。

jiayoushijie的博客 1558

LSTM+CRF Pytorch tutorial 之从原理到代码 # 摸着石头入门系列

Pytorch 给出的命名体识别(NER)的小例子,简洁清晰,深入原理及实现细节,比较适合想深入学习又没有好的入门途径的同学。不过他过于简洁,一些理论背景没有介绍,对于咱们这些,在门口晃悠的渣渣掌握起来还是有点儿费劲。 所以,本文打算总结自己的学习过程,从原理到代码,走一遍这个小例子,算是摸着石头入门吧~ outline: 这个模型的用途 模型的结构 几个关键代码的原理 (先保存,后续继续写。。。2020-5-18) ...

u014007701的博客 631

[学习笔记]pytorch tutorial

使用预训练的ResNet 18 CNN,有18层深(CNN的层数一般就是指具有权重/参数的层数总和),可以进行1000分类。会创建一个简单的flask应用,带有rest api,并且以json数据作为返回。实现激活函数:nn.xxx, torch.xxx, F.xxx。成更高维度的tensor,其拓展的维度由。3.如何保存和加载Checkpoint。4.在GPU/CPU上保存/加载。pytorch会进行数字数字分类。是将相同大小的tensor。2.只需要保存参数(推荐)衡量分类模型的表现。

zhangyifeng_1995的博客 1126

基于PyTorch的深度学习入门教程_sequence_models_tutorial

摘要 Sequence Models and Long-Short Term Memory Networks =================================================== 序列模型和LSTM网络 我们已经看到了各种前馈网络,也就是说,网络根本没有维护任何状态。这可能不是我们想要的行为。序列模型是NLP的核心:它们是在你的输入之间存在某种依赖关系的模型...

hufei_neo的博客 414

【RL】Pytorch简洁教程 | 坑点总结

训练一个神经网络通畅需要以下步骤: - 定义一个神经网络,通常有一些可以训练的参数 - 迭代一个数据集(Dataset) - 处理网络的输入 - 计算损失(会调用Module对象的`forward()`方法) - 计算损失函数对参数的梯度 - 更新参数,通常使用如下的梯度下降方法来更新:`weight=weight-learning_rate × gradien`。

发现问题,并解决问题,批判性思维 8644

PyTorch Tutorial

kernelreturn xprint(net)简单解释一下,这是一个简单的卷积神经网络,首先x是一个二维的Tensor(比如图像),这个图像的channel是1(可能是黑白的,当然也可能是彩色图像但是只使用其中的某个通道),对这个Tensor使用6个kernel大小为5*5,步长为1,padding为0的卷积(使用6个就代表输出会有6个channel),然后接入ReLU(激活函数,提供非线性),接着是max pooling(2*2,stride=kernel size=2)

Karen_Yu_的博客 1612

PyTorch-Tutorial-master_pytorch_

pytorch 教程,快速入门pytorch深度学习框架

PyTorch-Tutorials【pytorch官方教程中英文详解】- 1 Quickstart

原文链接:Learn the Basics — PyTorch Tutorials 1.10.1+cu102 documentation

csdn_xmj的博客 2056

PT32F030与MT6826S SPI通讯实战:从硬件连接到数据交互全流程解析

本文详细解析了PT32F030与MT6826S通过SPI通讯的全流程,包括硬件连接、电路设计、SPI外设初始化配置以及数据交互协议实现。通过实战案例和代码示例,帮助开发者快速掌握PT32F030与MT6826S的SPI通讯技术,实现精准的角度和速度数据采集。

weixin_29189373的博客 424

ShardingSphere-jdbc 5.5.0 + spring boot 基础配置 - 实战篇

shardingsphere 5.5.0移除了sm4算法,自己加上即可。增加spi扩展org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm增加以下代码:SM4算法代码/***/static {@Getter@Overrideif (!

qq_21903999的博客 4747

Pytorch入门tutorial学习

所有方法都可以在doc里面找到 一、transforms transforms表示是否对数据进行预处理 torchvision.transforms.Compose 一次完成多个transforms指令 Example transforms.Compose([ transforms.CenterCrop(10), transforms.ToTensor(), ]) 2.torchv...

Lilac的博客 392

生态位宽度计算&可视化展示(R语言)

物种的生态位越宽,该物种的特化程度就越小,倾向于泛化种(generalist species);物种的生态位越窄,倾向于是一个特化种(specialists species)。生态位宽度是指物种(或其它生物单位)在群落中所利用的各种不同资源的总和。本篇所使用为生态位宽度指数即**Levins的生态位宽度指数。

weixin_53705272的博客 4438

基于PyTorch的深度学习入门教程_tensor_tutorial

摘要 """ PyTorch是什么? ================ 这是一个基于python的科学计算程序包,针对两类用户: - NumPy的替代品,使用gpu的力量 -深度学习研究平台,提供最大的灵活性和速度 张量 张量类似于NumPy的ndarrays,另外张量还可以用于GPU加速计算。 ""' from __future__ import print_function im...

hufei_neo的博客 304

从SD更新字库到FLASH,再用LCD显示

用Flash当字库存储载体。思路是先将要用到的字库文件存在SD卡,然后存储到Flash,LCD显示时候从Flash中读取 还挺顺利的,移植的原子的程序,自己稍加修改,主要是我的液晶屏函数,Flash读写函数,还有存储文件的flash地址不一样。一晚上搞定,大小字体都OK。挺高兴哈哈。这几天忙工作事情有点耽搁了学习进展嘿嘿 在text.c的showstr函数中char的字体颜色随意设置的,可以显...

weixin_30505751的博客 915

【云原生技术】云计算与网络:容器服务(Tencent Kubernetes Engine,简称TKE)简介

基本概念主要特点应用场景技术实现容器服务(Tencent Kubernetes Engine,简称TKE)是腾讯云提供的一种托管的容器管理服务,基于开源的Kubernetes系统。TKE旨在简化容器的部署、管理和扩展,并且提供高性能、可靠性和安全性,适用于各种规模的企业和应用。

weixin_46453070的博客 2052

Pytorch入门④:TORCHVISION OBJECT DETECTION FINETUNING TUTORIAL

开始前需要有一个准备工作,安装coco的api,主要用到其中的IOU计算的库来评价模型的性能。我折腾了一个晚上加一个上午的时间,在我12年买的老笔记本上,按照网上很多方法还是无法解决。卡在了pycocotools问题上,最终的错误是:e:\anaconda3\include\pyconfig.h(59): fatal error C1083: 无法打开包括文件: “io.h”: No such f...

zqb15623113482的博客 1387

SpringBoot一次请求中缓存数据,请求结束就清除的4种方法,你会几种?

通过以上四种方法,你可以在 SpringBoot 的一次请求中缓存数据,并在请求结束后自动清除这些缓存数据。使用 ThreadLocal:适用于需要跨多个方法调用的缓存数据,灵活性高,但需要注意内存泄漏问题。使用 AOP:适用于全局性的缓存管理,代码更加优雅,但需要对 AOP 有一定的了解。使用 ServletRequestListener:适用于简单的请求生命周期管理,配置简单,但功能相对有限。使用 HttpServletRequest 的 setAttribute 和 getAttribute。

java专栏 1295

基于PyTorch的深度学习入门教程_cifar10_tutorial

摘要 """ 训练一个分类器 = = = = = = = = = = = = = = = = = = = = = 您已经了解了如何定义神经网络、计算损失和更新网络的权重。 现在你可能会想, 数据呢? ---------------- 通常,当必须处理图像、文本、音频或视频数据时,可以使用标准python包将数据加载到numpy数组中。然后你可以把这个数组转换成一个torch.*Tenso...

hufei_neo的博客 619

【QNX+Android虚拟化方案】136 - QNX 侧 Coredump 文件解析

【QNX+Android虚拟化方案】136 - QNX 侧 Coredump 文件解析

|~~~热爱生活、努力学习的小伙汁~~~| 1915

多 Agent 之间如何通信和协调?OpenClaw 的 Gateway 在其中扮演什么角色?

多 Agent 之间如何通信和协调?OpenClaw 的 Gateway 在其中扮演什么角色?

我哎GIS博客 1675

Pytorch官网tutorial快速入门教程(1)Quickstart

在这里,我们定义了批处理大小为64,也就是说,迭代器中的每个元素将返回一个包含64个特征和标签的批次。在下载完数据后,training_data和test_data变量中存储的是FashionMNIST类型的数据集对象,其中包含图像数据(转换为PyTorch张量)和对应的标签。我们在_ _init_ _函数中定义网络的层,并在forward函数中指定数据如何通过网络传递。在单个训练循环中,模型对训练数据集进行预测(按批次输入),然后通过反向传播将预测误差反馈给模型的参数以进行调整。

qilu_88的博客 244

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

基于PyTorch的深度学习入门教程_data_parallel_tutorial

摘要 可选的:数据并行性 = = = = = = = = = = = = = = = = = = = = = = = = = = **作者**:' Sung Kim <https://github.com/hunkim>' 和' Jenny Kang <https://github.com/jennykang>' 在本教程中,我们将学习如何使用多个gpu使用“数据并行...

hufei_neo的博客 666

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

如何使用Tutorial-Codebase-Knowledge快速掌握PyTorch深度学习项目:终极入门指南

面对复杂的PyTorch深度学习代码库感到无从下手?🤯 别担心!今天我要向你介绍一个神奇的工具——**Tutorial-Codebase-Knowledge**,它能将任何PyTorch项目瞬间转化为易于理解的教程。这个基于AI的代码库分析工具能够自动解析复杂的深度学习架构,为你生成清晰的入门指南,让你在几分钟内掌握项目的核心概念和设计思路。 ## 🚀 什么是Tutorial-Codebas

gitblog_00490的博客 539

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

基于PyTorch的深度学习入门教程_nlp_advanced_tutorial

提高版:做动态决策和Bi-LSTM CRF = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 动态和静态深度学习工具包 -------------------------------------------- Pytorch是一个...

hufei_neo的博客 540

基于PyTorch的深度学习入门教程_transfer_learning_tutorial

摘要 """ 迁移学习教程 = = = = = = = = = = = = = = = = = = = = = = = = = = **作者**:' Sasank Chilamkurthy ' _ 在本教程中,您将学习如何使用迁移学习来训练您的网络。您可以通过cs231n notes <https://cs231n.github.io/transfer-learning/>阅读更多...

hufei_neo的博客 469
上一篇: IID独立同分布假设
下一篇: UNILM 统一预训练模型 v1.0
Track48
博客等级 码龄10年 301粉丝 127原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值