ccc-pytorch-小实验合集（4）

最新推荐文章于 2024-07-19 16:12:05 发布
最新推荐文章于 2024-07-19 16:12:05 发布
阅读量250 收藏
点赞数
分类专栏： pytorch学习 文章标签： pytorch python 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liubi32326/article/details/129308032
版权

文章目录

一、 Himmelblau 优化

Himmelblau 是一个具有4个最优值的2维目标函数。其函数和最优值点如下：
在这里插入图片描述
图象绘制：

import numpy as np
from matplotlib import pyplot as plt

def himmelblau(x):
    return (x[0] ** 2 + x[1] - 11) ** 2 + (x[0] + x[1] ** 2 - 7) ** 2

x = np.arange(-6, 6, 0.1)
y = np.arange(-6, 6, 0.1)
print('x,y range:', x.shape, y.shape)
X, Y = np.meshgrid(x, y)
print('X,Y maps:', X.shape, Y.shape)
Z = himmelblau([X, Y])

fig = plt.figure('himmelblau')
ax = fig.add_subplot(projection='3d')
ax.plot_surface(X, Y, Z)
ax.view_init(60, -30)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()

在这里插入图片描述
Gradient Descent:

# [1., 0.], [-4, 0.], [4, 0.]
x = torch.tensor([-4., 0.], requires_grad=True)
optimizer = torch.optim.Adam([x], lr=1e-3)
for step in range(20000):
    pred = himmelblau(x)
	# 清空各参数的梯度
    optimizer.zero_grad()
    pred.backward()
    # 优化器更新参数x'=x-lr*梯度
    optimizer.step()

    if step % 2000 == 0:
        print ('step {}: x = {}, f(x) = {}'
               .format(step, x.tolist(), pred.item()))

在这里插入图片描述
给予x不同的初始化位置可以得到不同的收敛结果和次数。说明初始位置的选择对于收敛的过程和结果非常重要。

二、多分类实战-Mnist

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms


batch_size=200
learning_rate=0.01
epochs=10

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])),
    batch_size=batch_size, shuffle=True)
    
#Network Architecture
w1, b1 = torch.randn(200, 784, requires_grad=True),\
         torch.zeros(200, requires_grad=True)
w2, b2 = torch.randn(200, 200, requires_grad=True),\
         torch.zeros(200, requires_grad=True)
w3, b3 = torch.randn(10, 200, requires_grad=True),\
         torch.zeros(10, requires_grad=True)
#kaiming初始化
torch.nn.init.kaiming_normal_(w1)
torch.nn.init.kaiming_normal_(w2)
torch.nn.init.kaiming_normal_(w3)

def forward(x):
    x = x@w1.t() + b1
    x = F.relu(x)
    x = x@w2.t() + b2
    x = F.relu(x)
    x = x@w3.t() + b3
    x = F.relu(x)
    return x

optimizer = optim.SGD([w1, b1, w2, b2, w3, b3], lr=learning_rate)
# cross-entropy 等同于 softmax + log + nll_loss三个和
criteon = nn.CrossEntropyLoss()

for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):
        data = data.view(-1, 28*28)
        logits = forward(data)
        loss = criteon(logits, target)

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

        if batch_idx % 100 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))


    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data = data.view(-1, 28 * 28)
        logits = forward(data)
        test_loss += criteon(logits, target).item()

        pred = logits.data.max(1)[1]
        correct += pred.eq(target.data).sum()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

image-20230302210959169
注意事项：

  • Batch_Size太小导致收敛过慢，太大导致易陷入sharp minima，泛化性不好
  • 注意初始化这个关键步骤

三、Sequential与CPU加速-Mnist

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

batch_size=200
learning_rate=0.01
epochs=10

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])),
    batch_size=batch_size, shuffle=True)

class MLP(nn.Module):

    def __init__(self):
        super(MLP, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(784, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 10),
            nn.LeakyReLU(inplace=True),
        )

    def forward(self, x):
        x = self.model(x)

        return x

device = torch.device('cuda:0')
net = MLP().to(device)
optimizer = optim.SGD(net.parameters(), lr=learning_rate)
criteon = nn.CrossEntropyLoss().to(device)

for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):
        data = data.view(-1, 28*28)
        data, target = data.to(device), target.cuda()
        logits = net(data)
        loss = criteon(logits, target)

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

        if batch_idx % 100 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))

    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data = data.view(-1, 28 * 28)
        data, target = data.to(device), target.cuda()
        logits = net(data)
        test_loss += criteon(logits, target).item()

        pred = logits.argmax(dim=1)
        correct += pred.eq(target).float().sum().item()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

image-20230302212502896
注意事项：

  • MLP Class中对继承自父类的属性进行初始化，而且是用父类的初始化方法来初始化继承的属性。
  • Sequential 本质是一个可以添加组件的模块，输入通过组成的流水线后得到输出
  • 对于单卡计算机而言，使用torch.device(‘cuda’) 与 torch.device(‘cuda:0’)相同

四、visidom可视化

import  torch
import  torch.nn as nn
import  torch.optim as optim
from    torchvision import datasets, transforms
from visdom import Visdom

batch_size=200
learning_rate=0.01
epochs=10

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       # transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False, transform=transforms.Compose([
        transforms.ToTensor(),
        # transforms.Normalize((0.1307,), (0.3081,))
    ])),
    batch_size=batch_size, shuffle=True)

class MLP(nn.Module):

    def __init__(self):
        super(MLP, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(784, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 10),
            nn.LeakyReLU(inplace=True),
        )

    def forward(self, x):
        x = self.model(x)

        return x

device = torch.device('cuda:0')
net = MLP().to(device)
optimizer = optim.SGD(net.parameters(), lr=learning_rate)
criteon = nn.CrossEntropyLoss().to(device)

viz = Visdom()

viz.line([0.], [0.], win='train_loss', opts=dict(title='train loss'))
viz.line([[0.0, 0.0]], [0.], win='test', opts=dict(title='test loss&acc.',
                                                   legend=['loss', 'acc.']))
global_step = 0

for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):
        data = data.view(-1, 28*28)
        data, target = data.to(device), target.cuda()

        logits = net(data)
        loss = criteon(logits, target)

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

        global_step += 1
        viz.line([loss.item()], [global_step], win='train_loss', update='append')

        if batch_idx % 100 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))


    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data = data.view(-1, 28 * 28)
        data, target = data.to(device), target.cuda()
        logits = net(data)
        test_loss += criteon(logits, target).item()

        pred = logits.argmax(dim=1)
        correct += pred.eq(target).float().sum().item()

    viz.line([[test_loss, correct / len(test_loader.dataset)]],
             [global_step], win='test', update='append')
    viz.images(data.view(-1, 1, 28, 28), win='x')
    viz.text(str(pred.detach().cpu().numpy()), win='pred',
             opts=dict(title='pred'))

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

在这里插入图片描述

扔出去的回旋镖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Chinese-Text-Classification-Pytorch-mas
09-20
Chinese-Text-Classification-Pytorch-master。 数据齐全，说明文档详细。点击即用！ # 训练并测试： # TextCNN python run.py --model TextCNN # TextRNN python run.py --model TextRNN # TextRNN_Att python ...
PyTorch深度学习——搭建神经网络小实验
m0_43425029的博客
07-11 235
以下图片的CIFAR10神经网络模型框架来搭建神经网络： 由以下公式，解得padding=2 具体代码： import torch from torch import nn from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential from torch.utils.tensorboard import SummaryWriter class Siri(nn.Module): def __init__(self):
60 分钟入门 PyTorch ！这里有一份新手指南
实验楼
08-23 698
PyTorch是最优秀的深度学习框架之一，它简单优雅，非常适合入门。本文将介绍如何快速学习 PyTorch ，入门深度学习。2017 年初，Facebook 在机器学习和...
深度学习pytorch小实验
活到老学到老
04-24 1112
在这个实验中，我们将训练一个基本的人工神经网络（Artificial Neural Network，ANN）来进行手写数字的识别。这是一个简单的深度学习实验，我们使用PyTorch实现了一个用于手写数字识别的神经网络模型，并在MNIST数据集上进行了训练和测试。我们将进行多个epoch的训练，并在每个epoch之后测试模型的性能。然后，我们定义一个简单的神经网络模型。在这个实验中，我们将使用一个简单的两层全连接神经网络。然后，我们实例化这个神经网络模型，并定义一个损失函数和一个优化器。
实验总结-Pytorch 使用时的小技巧
kingsleyluoxin的博客
10-24 446
1. 固定网络的部分参数进行训练 简单方法，插入 with 块中，则块中的部分不会更新参数 s1 = torch.tensor([1.]) s2 = torch.tensor([1.]) with torch.no_grad(): s3 = s1 + s2 第一种方法不适用时，可以根据 model.children() 查看模型所有参数，从中选择将部分网络的 requires_gr...
pytorch 小例子 demo 使用demo
小欧欧的博客
08-03 9585
我使用anaconda3，建议大家也用这个，好用！！！ 假设你安装完了anaconda3. 一、创建一个测试Demo的实验环境 conda create -n PyTorch-demo python=3.6 The following NEW packages will be INSTALLED: ca-certificates: 2018.03.07-0 certi...
基于Pytorch的简单小案例
weixin_30376083的博客
04-17 986
　　神经网络的理论知识不是本文讨论的重点，假设读者们都是已经了解RNN的基本概念，并希望能用一些框架做一些简单的实现。这里推荐神经网络必读书目：邱锡鹏《神经网络与深度学习》。本文基于Pytorch简单实现CIFAR-10、MNIST手写体识别，读者可以基于此两个简单案例进行拓展，实现自己的深度学习入门。 环境说明 　　python 3.6.7 　　Pytorch的CUP版本 　　...
MVSNet-pytorch版 源码 MVSNet-pytorch-master
08-27
MVSNet_pytorch版 源码 MVSNet_pytorch-master MVSNet_pytorch版 源码 MVSNet_pytorch-master MVSNet_pytorch版 源码 MVSNet_pytorch-master MVSNet_pytorch版 源码 MVSNet_pytorch-masterMVSNet_pytorch版 源码 ...
d2l-zh-pytorch.pdf
02-14
4. 内存管理：PyTorch 中的内存管理是指对内存的管理和优化，以避免内存不足的情况。PyTorch 提供了多种方法来管理内存，包括将张量转换为 NumPy 数组、使用共享内存等。 5. 数据预处理：PyTorch 中的数据预处理是...
adversarial-attacks-pytorch:PyTorch对抗攻击的实现
05-12
对抗攻击PyTorch 是一个PyTorch库，其中包含对抗性攻击以生成对抗性示例。 干净的图像 对抗形象 目录 推荐的地点和配套 用法 :clipboard: 依存关系 火炬== 1.4.0 Python== 3.6 :hammer: 安装 pip install ...
Dive-into-DL-PyTorch.rar
06-10
13. **PyTorch与其他库的集成**：PyTorch可以很好地与OpenCV、TensorBoard等其他库配合使用，提升实验的可视化和调试能力。 通过阅读《Dive into DL PyTorch》，你将能够熟练掌握PyTorch的基本用法，从搭建简单的...
深度学习之pytoch小实验
qq_38225131的博客
11-04 307
搭建一个简易神经网络 #相关包的导入 import torch #导入必要的包 batch_n = 100 #在一个批次中输入数据的数量 hidden_layer = 100 #经过隐藏层后保留的数据特征的个数 input_data = 1000 #每个数据的数据特征是1000个 output_data = 10 #输出结果分类值是10 #从输入层到隐藏层，从隐藏层到输出层的权重初始化定义 x = torch.randn(batch_n, input_d
Pytorch的编译新特性TorchDynamo的工作原理和使用示例
deephub
07-17 4454
TorchDynamo 是一个由 PyTorch 团队开发的编译器前端，它旨在自动优化 PyTorch 程序以提高运行效率。TorchDynamo 的工作原理是在运行时动态分析和转换 PyTorch 的代码，然后将其转发给各种后端编译器（如 TorchScript、TVM、Triton 等），从而实现性能的提升。特别是在需要实时执行的应用中，如自动驾驶或金融预测等，深度学习模型要求快速执行。传统的优化技术经常需要在处理Python的动态特性时进行修订，这正是TorchDynamo的强项所在。
BiLSTM 实现股票多变量时间序列预测(PyTorch版)
君子不器 大道无方
07-17 1077
在本文中，我们将探讨如何使用PyTorch框架实现基于双向长短期记忆网络（BiLSTM）的多变量时间序列预测模型。多变量时间序列预测涉及多个输入变量和一个或多个输出变量，这些变量随时间变化并可能相互影响。通过利用BiLSTM的双向特性，我们的模型将能够同时考虑历史数据和未来趋势，从而更准确地预测时间序列的未来值。
pytorch的17个Loss和10个优化函数
最新发布
Seven597的博客
07-19 309
开始：
重学PyTorch，粗略笔记（二）dataset，dataloader
ziggybowie的博客
07-16 1234
自定义的数据集类必须实现三个函数：initlen, 和getitemgetitem从数据集中给定的索引 idx 处加载并返回一个样本函数len返回我们数据集中的样本数。# # 下载 Fashion MNIST 数据集# # 解压 gz 文件# # 读取二进制文件并转换为 numpy 数组import os# 下载 Fashion MNIST 数据集# 解压 gz 文件# 读取二进制文件并转换为 numpy 数组# 保存 numpy 数组到文件# 加载保存的 numpy 数组。
配置VSCode+Anaconda的PyTorch GPU环境笔记
Tomokochandesu的博客
07-17 863
叠个甲，我是纯菜鸟，说的不对你也别喷，喷了就是你对。网上的教程都太有年代感了，跟着配置就是到处报错，最后配置出来的也是老版本，用着十分膈应（我个人不喜欢老版本的东西），所以想着记录一下我踩过的坑，让大家以后少走点弯路。
【pytorch】thread: [16,0,0] Assertion `t ＞= 0 && t ＜ n_classes` failed
study_jiang_up的博客
07-17 200
标签label或者预测的结果pred，超出了数据的范围，比如标签里面只有0-15的数字，但是pred中出现19这个数字，那么在交叉熵损失计算中就会报错。
大规模优化问题，Scipy？Ceres？PyTorch！
Rain
07-17 176
优化问题一般通过scipy.optimize或者Ceres Solver优化器求解。但在参数量较大的优化问题上，scipy提供的BFGS、L-BFGS-B、CG、SLSQP等梯度优化算法其复杂度和存储需求指数级上升，无法满足计算效率；而Ceres需要额外的语言来支持，当前算法工程师一般以python为主，学习成本较大。且项目环境需要多语言混编，配置与部署难度较大。 本文使用PyTorch/TensorFlow等机器学习框架，通过自动求导高效计算梯度，避免手动计算梯度复杂性，利用CPU/CPU来加速求解优化
mvsnet-pytorch版 源码 mvsnet-pytorch-master运行结果
11-17
mvsnet-pytorch-master是对该网络的源代码进行了整理和更新，使其更加易于使用和理解。 当我们运行mvsnet-pytorch-master时，首先需要准备输入数据，包括多个视角的图像和相机参数。然后，我们可以使用训练好的模型...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值