深度学习实验（二）——使用AutoGrad

已于 2024-01-29 20:33:57 修改
阅读量408 收藏
点赞数
分类专栏： # 深度学习实验 文章标签： 深度学习 python
于 2022-12-03 22:37:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/code_bro/article/details/128167665
版权

深度学习实验二: 使用AutoGrad

name = '杨宇海'#填写你的姓名
sid = 'B02014152'#填写你的学号

print('姓名:%s, 学号:%s'%(name, sid))

import torch
import numpy as np
import matplotlib.pyplot as plt

1. 使用张量的自动求导计算一元函数的导数

请按以下要求，使用张量编写代码，计算sigmoid函数的导数，并绘制曲线图。

#在下面定义一个用于计算sigmoid的函数
def sigmoid(z):
    a = 1/(1+torch.exp(-z))     #请用一行代码实现
    return a

#测试sigmoid函数:
print(sigmoid(torch.tensor([-1,0,1],dtype = torch.float32)))

#在[-5,5]区间等间隔取100个数，得到一维张量x

x = torch.linspace(-5,5,100,dtype = torch.float32)#请用一行代码实现

print(x.shape)

x.requires_grad

#在下面设置张量x的requires_grad属性为True

x.requires_grad = True

x.grad is None

x.grad_fn is None

y = sigmoid(x)

y.grad_fn

plt.plot(x.detach().numpy(),y.detach().numpy(),'r-')
plt.show()

#在下面编写代码，计算y的元素和 
z =  y.sum() #请用一行代码实现


# print(z.item())

#使用Autograd，反向传播，得到x的梯度
#请用一行代码实现,提示:Tensor.backward()
z.backward(retain_graph=True) # 这里retain_graph动态图不释放，以便后面继续反向传播
# z.backward()

# x.grad.zero_()
x.grad

plt.plot(x.detach(), y.detach(),'r-')
plt.plot(x.detach(), x.grad.detach(),'k-')
plt.show()

#在下面尝试第二次执行反向传播，看看结果是什么
z.backward()
print(x.grad)
plt.plot(x.detach(), y.detach(),'r-')
plt.plot(x.detach(), x.grad.detach(),'k-')
plt.show()
# 发现导数在原有基础上翻倍，说明梯度累加

2. 使用torch.optim训练线性分类器

编写一个softmax分类器模型，并用torch.optim训练

下面的代码生成一个一组随机2维样本，包含了三个类别，每个类别有100个样本

x0 = torch.randn((2,100))*0.5 + torch.tensor([[0.5],
                                              [0.5]])
x1 = torch.randn_like(x0)*0.5 - 1
x2 = torch.randn_like(x0)*0.5 + torch.tensor([[-1.5],[1.5]])

x = torch.hstack((x0,x1,x2))
y = torch.hstack((torch.zeros(1,100), torch.zeros(1,100)+1, torch.zeros(1,100)+2)).squeeze()

plt.plot(x[0,y==0],x[1,y==0],'r*')
plt.plot(x[0,y==1],x[1,y==1],'bo')
plt.plot(x[0,y==2],x[1,y==2],'kd')
plt.axis('tight')
plt.axis('equal')
plt.show()

#定义Softmax函数
def softmax(z):
    ###假设z是一个d行n列的张量，每一列表示一个样本
    #第一步，对每一列减去该列的最大值,提示:Tensor.max(...).values
    z = z - z.max(dim=0)[0]  #请用一行代码实现
    #第二步，计算指数变换
    a = z.exp()  #请用一行代码实现
    #第三步，归一化每一列为一个概率分布
    a = a/a.sum(dim=0)   #请用一行代码实现
    return a

#测试softmax函数
dummy = torch.rand((3,10),dtype = torch.float32)
softmax(dummy)

import torch.optim as optim

#定义Softmax分类器模型,用一个类表示
class SoftmaxClassifier:
    def __init__(self, in_features, out_features):#编写构造函数，记录输入特征和输出特征的维度，并初始化参数
        self.in_features = in_features
        self.out_features = out_features
        self.__initialize__()
                
    def __initialize__(self):#编写参数初始化函数，初始化权重矩阵和偏置向量
        # 初始化为0或者小随机值
        self.W = torch.zeros([self.out_features,self.in_features], requires_grad=True)
        # self.W = torch.zeros([self.out_features,self.in_features])
        self.b = torch.zeros([self.out_features,1], requires_grad=True)
        stp = self.W+self.b
        # self.b = torch.zeros([self.out_features,1])

    def predict(self, X):#编写预测函数，调用前面定义的softmax函数
        print("W.size():", self.W.size())
        print("X.size():", X.size())
        # z = (self.W)@X.cuda() + self.b#请用一行代码实现
        z = (self.W)@X + self.b#请用一行代码实现
        a = softmax(z)#请用一行代码实现
        return a
    
    def fit(self, X,Y, lr = 0.1):#编写训练函数
        #第一步，初始化参数
        #请用一行代码实现
        self.__initialize__()
        
        #将Label Y转换为one-hot vector Y1
        # Y1 = torch.zeros((self.out_features,X.size(1))).cuda()
        Y1 = torch.zeros((self.out_features,X.size(1)))
        Y1[Y,torch.arange(X.size(1))] = 1


        l0 = 0
        epsilon = 1e-6
        iter = 0
        
        #第二步，定义优化器为SGD
        #请用一行代码实现
        optimizer = optim.SGD(params=[self.W, self.b],lr = lr)
        while True:
            #1. 将参数的梯度置为0，提示zero_grad(),请用一行代码实现
            optimizer.zero_grad()
    
            #2. FP:对训练样本做出预测
            rho = self.predict(X)#请用一行代码实现
            
            #3.计算softmax loss
            l = -torch.log(rho[Y1 == 1]).mean()#请用一行代码实现  
            print(rho.size())
            print(Y1.size())
            print(rho[Y1==1].size())


            l1 = l.detach().item()
            # print(l1)
            
            print('iter = %d, loss = %f\n'%(iter,l1))
            iter = iter + 1
            
            if abs(l1-l0)<epsilon:
                break
            l0 = l1
            
            #4.BP:更新梯度,请用一行代码实现
            l.backward()
            
            #5. GD: 更新权重,请用一行代码实现
            optimizer.step()

   

#测试SoftmaxClassifier
cls = SoftmaxClassifier(2,3)
cls.predict(x[:,:10])

#训练模型

cls = SoftmaxClassifier(2,3)
y = y.to(torch.int64)
cls.fit(x,y)


#评估训练结果
#应该达到95%以上准确率
with torch.no_grad():
    rho = cls.predict(x)
    print(rho.size())
    yhat = rho.argmax(dim = 0)
    print(yhat.size())
    acc = (yhat==y).to(torch.float32).mean().item()

    print('accuracy = ',acc)

3. （选做）用上面定义的softmax对MNIST手写体分类

import torch
import numpy as np
import matplotlib.pyplot as plt
from torchvision import datasets,transforms

data_path = '../data/'
mnist_train = datasets.MNIST(data_path,download=True,train = True,transform = transforms.ToTensor())
mnist_test =  datasets.MNIST(data_path,download=True,train = False,transform = transforms.ToTensor())

import torch
train_loader = torch.utils.data.DataLoader(mnist_train, batch_size = 32, shuffle = True)
test_loader = torch.utils.data.DataLoader(mnist_test, batch_size = 32, shuffle = True)

import torch.optim as optim

#定义Softmax函数
def softmax(z):
    ###假设z是一个d行n列的张量，每一列表示一个样本
    #第一步，对每一列减去该列的最大值,提示:Tensor.max(...).values
    z = z - z.max(dim=0)[0]  #请用一行代码实现
    #第二步，计算指数变换
    a = z.exp()  #请用一行代码实现
    #第三步，归一化每一列为一个概率分布
    a = a/a.sum(dim=0)   #请用一行代码实现
    return a

# 定义Softmax分类器模型,用一个类表示
class SoftmaxClassifier:
    def __init__(self, in_features, out_features):# 编写构造函数，记录输入特征和输出特征的维度，并初始化参数
        self.in_features = in_features
        self.out_features = out_features
        self.__initialize__()
                
    def __initialize__(self):# 编写参数初始化函数，初始化权重矩阵和偏置向量
        # 初始化为0或者小随机值
        self.W = torch.zeros([self.out_features,self.in_features], requires_grad=True)
        # self.W = torch.zeros([self.out_features,self.in_features])
        self.b = torch.zeros([self.out_features,1], requires_grad=True)
        stp = self.W+self.b
        # self.b = torch.zeros([self.out_features,1])
        self.l0 = 0

    def predict(self, X):# 编写预测函数，调用前面定义的softmax函数
        # print("W.size():", self.W.size())
        # print("X.size():", X.size())
        # z = (self.W)@X.cuda() + self.b#请用一行代码实现
        z = (self.W)@X + self.b#请用一行代码实现
        a = softmax(z)#请用一行代码实现
        return a
    
    def fit(self, X,Y, lr = 0.1):# 编写训练函数
        # 第一步，初始化参数
        # 请用一行代码实现
        # self.__initialize__()
        
        # 将Label Y转换为one-hot vector Y1
        # Y1 = torch.zeros((self.out_features,X.size(1))).cuda()
        Y1 = torch.zeros((self.out_features,X.size(1)))
        Y1[Y,torch.arange(X.size(1))] = 1


        # self.l0 = 0
        epsilon = 1e-6
        iter = 0
        
        #第二步，定义优化器为SGD
        #请用一行代码实现
        optimizer = optim.SGD(params=[self.W, self.b],lr = lr)
        while True:
            #1. 将参数的梯度置为0，提示zero_grad(),请用一行代码实现
            optimizer.zero_grad()
    
            #2. FP:对训练样本做出预测
            rho = self.predict(X)#请用一行代码实现
            
            #3.计算softmax loss
            l = -torch.log(rho[Y1 == 1]).mean()#请用一行代码实现  
            # print(rho.size())
            # print(Y1.size())
            # print(rho[Y1==1].size())


            l1 = l.detach().item()
            # print(l1)
            
            # print('iter = %d, loss = %f\n'%(iter,l1))
            iter = iter + 1
            
            if abs(l1-self.l0)<epsilon:
                break
            self.l0 = l1
            
            #4.BP:更新梯度,请用一行代码实现
            l.backward()
            
            #5. GD: 更新权重,请用一行代码实现
            optimizer.step()
   

# 初始化模型
cls = SoftmaxClassifier(784,10)
max_batch_idx = 50
# 训练模型
def train():
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, label = data

        inputs = inputs.reshape([32, 784]).permute(1,0)
        label = label.to(torch.int64)

        cls.fit(inputs, label)
        print('batch_idx = %d, loss = %f'%(batch_idx,cls.l0))
        # 训练max_batch_idx个batch就退出
        if batch_idx == max_batch_idx:
            break
train()

def test():
    correct = 0 # 正确分类样本
    total = 0 # 总样本
    with torch.no_grad(): 
        # 这里之后的计算都不会更新模型参数，仅用于模型测试
        for batch_idx, data in enumerate(test_loader, 0):
            inputs, label = data
            batch_size_input = int(inputs.numel()/784)
            inputs = inputs.reshape([batch_size_input, 784]).permute(1,0)
            label = label.to(torch.int64)
            _,predicted = torch.max(cls.predict(inputs), dim=0) # 预测结果
            total += label.size(0) # 累计样本数，添加到计数器total
            correct += (predicted == label).sum().item() # 累计预测正确的样本数 
    print('accuracy on test set: %d %% ' % (100*correct/total)) # 打印正确样本和总样本的商

test()
# max_batch_idx = 10  ===>  81% 
# max_batch_idx = 20  ===>  82% 
# max_batch_idx = 30  ===>  81% 
# max_batch_idx = 50  ===>  86% 
# max_batch_idx = 100  ===>  83% 


# 找出第index个图片作展示

# 设置展板尺寸
fig = plt.figure(figsize=(5,5))
# 展示图片1
ax1 = fig.add_subplot(141)
ax1.set_title(torch.max(cls.predict(mnist_train[0][0].reshape([784,1])),dim=0)[1].item())
plt.imshow(transforms.ToPILImage()(mnist_train[0][0]))
# 展示图片2
ax2 = fig.add_subplot(142)
ax2.set_title(torch.max(cls.predict(mnist_train[10][0].reshape([784,1])),dim=0)[1].item())
plt.imshow(transforms.ToPILImage()(mnist_train[10][0]))
# 展示图片3
ax3 = fig.add_subplot(143)
ax3.set_title(torch.max(cls.predict(mnist_train[20][0].reshape([784,1])),dim=0)[1].item())
plt.imshow(transforms.ToPILImage()(mnist_train[20][0]))
# 展示图片4
ax4 = fig.add_subplot(144)
ax4.set_title(torch.max(cls.predict(mnist_train[30][0].reshape([784,1])),dim=0)[1].item())
plt.imshow(transforms.ToPILImage()(mnist_train[30][0]))
introversi0n
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
pytorch.autograd使用示例
学-> 思->用
12-24 242
pytorch.autograd使用示例 # -*- coding:utf-8 -*- # /usr/bin/python ''' ------------------------------------------------- File Name ： autograd_demo Description : Envs : Author ...
深度学习框架PyTorch-- 第三章Tensor和Autograd
ysl的博客
06-04 1193
Tensor """ Tensor又名张量,读者可能对这个名词似曾相识，因它不仅在PyTorch中出现过，它也是Theano、TensorFlow、 Torch和MxNet中重要的数据结构。 关于张量的本质不乏深度的剖析，但从工程角度来讲，可简单地认为它就是一个数组，且支持高效的科学计算。 它可以是一个数（标量）、一维数组（向量）、二维数组（矩阵）和更高维的数组（高阶数据）。 Tensor和...
PyTorch-1.10(十二)--torch.autograd基本用法
Hanscal
05-15 1069
Torch.autograd torch.autograd提供实现任意标量值函数自动微分的类和函数。只需要对现有代码进行最小的更改（声明张量，设置使用requires_grad=True关键字计算其梯度）. 到目前为止，pytorch只支持浮点张量类型( half, float, double and bfloat16) 和复数张量类型(cfloat, cdouble)的autograd。 backward 计算给定张量相对于图叶节点的梯度之和。 ...
autograd：自动微分
Spring_24的博客
08-27 453
本文介绍PyTorch 中的autograd机制。
【fairseq】RuntimeError: Unrecognized tensor type ID: AutogradCUDA
最新发布
Learning from the mistakes
11-26 1742
今天在运行网上搜了一下可能是torch版本的原因，我的torch版本是torch-1.8.1+cu102。
深度学习实验——猫狗分类代码
06-13
在本“深度学习实验——猫狗分类代码”中，我们将探讨如何使用深度学习技术来解决一个常见的计算机视觉问题：区分图像中的猫和狗。这个任务是图像分类的一个实例，它涉及训练模型识别图像中的特定类别。深度学习，...
中国科学院大学深度学习课程实验作业——自动写诗（代码+实验报告）
01-14
本文致力于解决和完成自然语言处理中的难题之一——机器自动写诗，采用循环神经网络(RNN)的变体长短时记忆网络（Long Short Term Memory networks， LSTM），通过合理的设计网络结构和算法实现了自动写诗和藏头诗的...
中国科学院大学深度学习课程实验作业——猫狗分类（代码+实验报告+指导说明+PPT）
06-06
图像分类是根据图像的语义信息将不同类别图像区分...本文使用pytorch编程框架实现经典且强大的VGG16网络进行猫狗识别分类的任务。实验表明，在给定的验证集上，该方法轻松达到了88%+的准确率，取得了不错的性能效果。
中国科学院大学深度学习课程实验作业——手写数字识别（代码+实验报告）
01-14
手写数字识别是机器学习的经典任务之一，本文设计了一种简单的卷积神经网络(CNN)来完成手写数字识别任务，并采用pytorch框架搭建，其准确率在测试集高达99%，取得了不错的效果。
中国科学院大学深度学习课程实验作业——电影评论情感分类（代码+实验报告）
01-14
由于个人原因，核心代码忘记上传，已经在这上传了完整版https://download.csdn.net/download/HowardEmily/15876211?spm=1001.2014.3001.5503 抱歉！
【PyTorch】02基础知识---张量与autograd
qq_41566530的博客
05-21 317
2 PyTorch基础知识 官方文档：https://pytorch.org/docs/ 2.1 安装与配置 人工智能工具库(Anaconda/Pytorch/PyCharm等)安装环境配置视频教程 深度学习环境搭建（从卸载CUDA到安装，以及Pytorch与torchvision的安装） 【PyTorch】1.1 PyTorch简介和安装 重新创建并切换使用虚拟环境的步骤： 退出当前虚拟环境：conda deactivate 创建虚拟环境：conda create -n pytorch_1.7
autograd机制
weixin_44627093的博客
08-13 157
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4zRgepxz-1660359180011)(./img/2.png)]虽然没有指定t的requires_grad但是需要用到它，也会默认的。构造一组输入数据X和其对应的标签y。指定好参数和损失函数。...
04_Pytorch生态、PyTorch能做什么、PyTorch之Autograd、autograd案例、GPU加速案例
涂作权的博客
01-14 348
1.4.初见PyTorch 1.4.1.PyTorch生态 1.4.2.PyTorch能做什么？ GPU加速 自动求导 常用网络层 nn.Linear nn.Conv2d nn.LSTM nn.ReLU nn.Sigmoid nn.Softmax nn.CrossEntropyLoss nn.MSE 1.4.3.PyTorch之Autograd 以下部分来自：https://www.cnblogs.com/xueqiuqiu/p/7513721.html 在PyTorch中，autograd是
关于Pytorch中autograd的若干（踩坑）总结
watermelon1123的博客
05-17 9279
目录 关于Variable和Tensor 叶子节点leaf autograd操作 Tensor.data和Tensor.detach() autograd.grad和hook 关于Variable和Tensor 旧版本的Pytorch中，Variable是对Tensor的一个封装；在Pytorch大于v0.4的版本后，Varible和Tensor合并了，意味着Tensor可以像...
libtorch-入门autograd
qq_27009517的博客
01-04 606
libtorch download https://github.com/pytorch/examples/tree/master/cpp/autograd cuda version hlx@W240F1:~/下载$ cat /usr/local/cuda/version.txt CUDA Version 10.0.130 CUDA Patch Version 10.0.130.1 hlx@W240F1:~/下载$ hlx@W240F1:~/libtor...
torch.autograd.Variable(target.cuda(async=True)) ---用async调用cuda()出现 SyntaxError: invalid syntax
com_fang_bean的博客
09-27 2841
直接把cuda（async=true）中的async=true去掉即可。
Torch Autograd详解
热门推荐
Blog Life
03-30 1万+
1.autograd自动微分 假如我们有一个向量x=(1,1)当成input，经过一系列运算得到了output变量y,如下图所示： 如图所示，向量x经过与4和自身相乘之后得到向量z，z再求长度，得到y 我们想要求y关于x的微分时，pytorch会帮我们自动求解。 from torch.autograd import Variable import torch x = Variable(torch...
RMSpro优化器中rho与decay 两参数的区别（keras)
只想买把蝴蝶knife
02-03 4504
最近在学习 efficienet 使用了 RMSProp 优化器，但是在 keras 使用的时候发现了问题 keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0) RMSprop的初始化中有rho与decay两个参数，但是这两个参数都是衰减因子，那他们之间的区别在哪里呢，官方链接也没有详细解释， 后来在看到一篇回答...
PyTorch学习笔记——（4）autograd.grad()函数和backward()函数介绍及使用
Ma Sizhou
02-16 3952
目录1、`torch.autograd.grad()`2、`.torch.autograd.backward()`： 1、torch.autograd.grad() torch.autograd.grad( outputs, inputs, grad_outputs=None, retain_graph=None, create_graph=False, only_inputs=True, allow_unused=False) 参数： outputs: ..
《Python深度学习》2018中文版1
08-04
这本书使用Keras进行深度学习的实践，因此需要读者具备一定的Python编程水平。 本书的优点之一是作者的出色经验和知识，作者是Keras的创始人之一，目前在Google担任人工智能研究员，所以他对深度学习领域有着丰富的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

introversi0n

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值