python深度学习入门学习笔记——更新中

已于 2023-10-31 23:42:37 修改
阅读量906 收藏 2
点赞数 30
分类专栏： Python学习 深度学习/机器学习 文章标签： python 深度学习 学习 笔记 pytorch
于 2023-10-29 23:35:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50714222/article/details/133915931
版权

现在在跟着小土堆博主我是土堆的个人空间-我是土堆个人主页-哔哩哔哩视频学习pytorch深度学习的有关知识，这篇文章记录学习时的一些笔记。后面会随着学习进度不断更新

目录

两大法宝函数

pycharm 和 jupyter使用对比

加载函数Dataset 、Dataloader

  torch.utils.data介绍

先从命令行查看图片相关属性

获取所有图片的地址

完整代码

 TensorBoard的使用

安装和导入

add_scalar函数使用

add_image函数使用

torchvision中的transforms

transforms结构及用法

常见的Transforms

python中__call__的用法

ToTensor的使用

 Normalize的使用

Resize的使用

pycharm小技巧设置

 Compose的使用

RandomCrop的使用

使用方法总结

torchvision中数据集使用

dataset

dataloader

神经网络的基本骨架——nn.Module的使用

神经结构的基本使用

卷积层 Convolution Layers

卷积操作【选看】

 开始正题【Conv2d】

神经网络——最大池化的使用

MaxPool2d

神经网络——非线性激活（变换）

ReLU

Sigmoid

神经网络——线性层及其他层介绍

两大法宝函数

  • dir()：打开，看见
  • help(): 说明书

当对函数的功能、用法等有疑惑时，可以使用上面两个函数来进行查看学习。例如下面查看sum这个函数的相关信息。

pycharm 和 jupyter使用对比

加载函数Dataset 、Dataloader

  torch.utils.data介绍

Dataset方法属于torch.utils.data库。所以必须提前下载好这个库。

1）安装此次环境需要的库

conda install -c conda-forge torch-data-utils

注意：上面是cuda环境下的安装命令，如果不是cuda环境，可以直接使用pip指令进行安装

pip install torch_data_utils

#另一种写法
pip install torch-data-utils
#我是用的conda环境安装指令，pip指令网上提供了这两种写法，大家可以试试

 torch.utils.data主要包括下面三个类：

【这里的介绍参考了PyTorch之torch.utils.data_spyder torch.utils.data安装-CSDN博客】
1.class torch.utils.data.Dataset
作用：创建数据集，有__getitem__(self, index)函数来根据索引序号获取图片和标签，有__len__(self)函数来获取数据集的长度。
其它的数据集类必须是torch.utils.data.Dataset的子类,比如说torchvision.ImageFolder
2.class torch.utils.data.sampler.Sampler(data_source)
参数：data_source(Dataset) —dataset to sample from
作用：创建一个采集器，class torch.utils.data.sampler.Sampler是所有的Sampler的基类，其中，iter(self)函数来获取一个迭代器，对数据集中元素的索引进行迭代，len(self)方法返回迭代器中包含元素的长度。

3.class torch.utils.data.DataLoader(dataset,batch_size=1,shtffle=False,sampler=None,batch_sampler=None,num_workers=0,collate_fn=,pin_memory=False,drop_last = False,timeout=0,worker_init_fn=None)

  •  dataset(Dataset):加载数据的数据集
  • batch_size(int ,optional):每批加载多少个样本
  •  shuffle(bool,optional）：设置为"真"时，在每个epoch对数据打乱（默认：flase)
  • sampler(Sampler,optional):定义从数据集中提取样本的策略，返回一个样本
  • batch_sampler(Sampler,optional):like sampler, but returns a batch of indices at a time返回一批样本，与batch_size，shuffle,sampler和drop_last互斥。
  • num_workers(int,optional)：用于加载数据的子进程数。0表示将在主进程中加载。

先从命令行查看图片相关属性

可以直接复制图片的路径，有两种方式，绝对路径和相对路径。如果选择绝对路径，也就是下面代码注释的那条，那么注意是两条斜杠。

from PIL import Image
img_path = "dataset/train/ants/0013035.jpg" #可以直接复制图片路径
# img_path = "C:\\Users\\Administrator\\PycharmProjects\\pythonProject2\\dataset\\train\\ants\\0013035.jpg"
img = Image.open(img_path)

此时右侧可以看到对应的图片属性

 显示照片，会弹出相应的照片。

img.show()

获取所有图片的地址

dir_path = "dataset/train/ants"
import os
img_path_list = os.listdir(dir_path)
img_path_list[0]
Out[17]: '0013035.jpg'

在命令行查看图片属性后，就可以根据自己的需要完善函数内容了

完整代码

class MyData(Dataset):
    def __init__(self, root_dir, label_dir):
        # 获取所有图片的地址
        self.root_dir = root_dir
        self.label_dir = label_dir
        # 图片地址path = 根地址root_dir + 标签label_dir
        self.path = os.path.join(self.root_dir, self.label_dir)
        self.img_path = os.listdir(self.path)

    # 获取图片的地址和标签
    def __getitem__(self, idx):
        img_name = self.img_path[idx]
        img_item_path = os.path.join(self.root_dir, self.label_dir, img_name)
        img = Image.open(img_item_path)
        label = self.label_dir
        return img, label

    # 获取数据集的长度
    def __len__(self):
        return len(self.img_path)

 然后就可以调用并使用类啦。

root_dir = "dataset/train"
ants_label_dir = "ants"
bees_label_dir = "bees"
ants_dataset = MyData(root_dir, ants_label_dir)
bees_dataset = MyData(root_dir, ants_label_dir)
# 获取整个数据集 对两个小的数据集进行拼接
train_dataset = ants_dataset + bees_dataset

 TensorBoard的使用

安装和导入

安装tensorboard

在pycharm终端输入命令即可安装

使用前需要导入

# 从工具箱导入tensorboard 导入SummaryWriter
from torch.utils.tensorboard import SummaryWriter

在pycharm中按住ctrl 然后点击类名就可以挑转到该类的详细介绍信息文件，如下所示。

当然也可以在命令控制台输入help获取相关的详细信息介绍

add_scalar函数使用

writer = SummaryWriter("logs")

# writer.add_image()
for i in range(100):
    writer.add_scalar("y=2x", 2 * i, i)

writer.close()

打开logs文件【在终端输入命令】

点击箭头指向的链接即可打开窗口，如下所示。

 如果一台服务器是多个人使用，然后默认打开端口都是同一个6006。如果同时有人使用就很麻烦，所以可以在打开时指定打开的窗口号。如下所示，将端口指定为6007。

add_image函数使用

利用Opencv读取图片，获得numpy型图片数据

在终端先试用命令安装

 注意add_image()函数中参数的格式，需要进行转换

  • np.array():将图片的类型转换为numpy型
  • 从PIL到numpy，需要在add_image()中指定shape中每一个数字/维表示的含义，可以通过dataformats=''指定。

对应的代码

import numpy as np
from PIL import Image

writer = SummaryWriter("logs")
image_path = "data/train/ants_image/0013035.jpg"
img_PIL = Image.open(image_path)
img_array = np.array(img_PIL)
print(type(img_array))  # <class 'numpy.ndarray'>
print(img_array.shape)  # (512, 768, 3)
# 参数依次为 文件名 图片名 步骤 shape数字含义
writer.add_image("test", img_array, 1, dataformats='HWC')  # 1表示步骤1

这样就可以清楚的观察训练过程中给model传入了那些数据。【拖动小圆点查看】

torchvision中的transforms

transforms主要功能：选择工具对特定格式的图片进行相应的变化。

transforms结构及用法

可以按住ctrl再点击transforms查看该功能，点击后会打开一个transformer.py文件，该文件相当于工具箱，该文件的类就相当于工具。

注意：tensor数据类型

在写函数参数时，按ctrl+P可以显示需要什么参数

学习代码

from PIL import Image
from torchvision import transforms

# python的用法 -> tendor数据类型
# 通过 transforms.ToTensor去看两个问题
# 1、transforms该如何使用(python)
# 2、为什么我们需要Tensor数据类型

img_path = "data/train/ants_image/6743948_2b8c096dda.jpg"
img = Image.open(img_path)
print(img)  # <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=375x500 at 0x1F08C0C2F90>
tensor_trans = transforms.ToTensor()
# transforms该如何使用(python)
tensor_img = tensor_trans(img)
print(tensor_img)

输出结果

可以在控制台查看相关属性

神经网络训练一定会用到tensor类型！

用法结构示意图：

使用opencv的方式进去读取

 写日志

 控制台查看日志

常见的Transforms

主要关注输入和输出

python中__call__的用法

首先引入transforms可以在左侧查看结构【类和函数】

from torchvision import transforms

看下面的代码来理解

class Person:
    # 有下划线说明是内置函数
    def __call__(self, name):
        print("__call__" + "hello" + name)

    def hello(self, name):
        print("hello" + name)


person = Person()
person("zhangsan")  # 使用call调用 可以直接传参使用
person.hello("lishi")  # 使用自定义方法调用，需要.方法

ToTensor的使用

功能：转换对象类型为Tensor类型

可以在transforms.py文件中查看该类的相关使用说明

学习代码【useful_Transformers.py】

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms


writer = SummaryWriter("logs")  # 简单配置ToTensor
img = Image.open("dataset/train/bees/16838648_415acd9e3f.jpg")
print(img)  # <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x450 at 0x1CE7736AD50>

trans_totensor = transforms.ToTensor()  # 创建一个对象
img_tensor = trans_totensor(img)
# 注意：运行前需要将之前的日志删除哦
writer.add_image("ToTensor", img_tensor)
writer.close()

可以运行在终端输入命令进行查看

 Normalize的使用

功能：归一化

计算公式 output[channel] = (input[channel] - mean[channel]) / std[channel]

学习代码

# Normalize的使用 重点理解归一化 计算公式 output[channel] = (input[channel] - mean[channel]) / std[channel]
print(img_tensor[0][0][0])  # tensor(0.0980)
# 后面参数的值会影响归一化的结果 可以随意更改参数值进行测试。
trans_norm = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])  # 输入的第一个参数是标准差mean 第二个是std
img_norm = trans_norm(img_tensor)
print(img_norm[0][0][0])  # tensor(-0.8039)
writer.add_image("Normalize", img_norm)

 

第一张是归一化后的结果，第二张时归一化前的结果。

Resize的使用

学习代码

# Resize
print(img.size)  # (500, 450)
trans_resize = transforms.Resize((512, 512))
img_resize = trans_resize(img)
# img PIL -> resize -> img_resize PIL
print(img_resize)  # <PIL.Image.Image image mode=RGB size=512x512 at 0x1FD57F4BA10>
# img_resize PIL-> totensor -> img_resize tensor
img_resize = trans_totensor (img_resize)
print(img_resize)  # 输出结果是一个tensor
writer.add_image("Resize", img_resize, 0)

#Compose ->resize - 2
trans_resize_2 = transforms.Resize(512)
# PIL -> resize -> PIL -> totensor -> tensor [类型变换]
trans_compose = transforms.Compose([trans_resize_2, trans_totensor])
img_resize_2 = trans_compose(img)
writer.add_image("Resize", img_resize_2, 1)
pycharm小技巧设置

 Compose的使用

功能：对transform的相关进行组合，使成一个代码块

示例和上面的resize是一起的

compose()中的参数需要的是一个列表。在python中，列表的表示形式为[数据1，数据2，...]

在Compose中个，数据需要的是transforms类型，所以得到,Compose([transforms参数1，transforms参数2，...])

RandomCrop的使用

功能：随机裁剪【用得不多】

学习代码

# RandomCrop
trans_random = transforms.RandomCrop(256)
# 先裁剪 然后转换成tensor类型
trans_compose_2 = transforms.Compose([trans_random, trans_totensor])
for i in range(10):
    img_crop = trans_compose_2(img)
    writer.add_image("RandomCrop", img_crop, i)

之前那张蜜蜂的照片裁剪完一个大眼睛，不咋好看，就换了张图片来进行测试。

使用方法总结

当不清楚类或者函数的用法时，可以看官方文档，比网上搜索的信息准确

一定要注意输出和输出的需要什么参数和参数的类型

如果不知道返回值时，可以进行如下操作进行查看【试错或者直接网上查】

  • print()
  • print(type())
  • debug

上面的学习内容总结：学习了tensorboard需要tensor数据类型，同时可以使用transfoms里面的方法进行变换，然后输出或展示。

torchvision中数据集使用

这部分的结果后面补充，因为网不好，所以数据集没有下载下来，暂时还没有实验结果。

dataset

学习代码【dataset_transforms.py】

# 如何使用torchvision提供的数据集
import torchvision
from torch.utils.tensorboard import SummaryWriter
# 将数据【图片】转换成tensor类型并根据自己的需求进行变换

dataset_transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])
# 参数依次为：数据集下载的地址 是否为训练集 设置transform 是否从网上下载【数据不会重复下载的，不用担心】
train_set = torchvision.datasets.CIFAR10(root="./dataset", train=True, transform=dataset_transform, download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset", train=False, transform=dataset_transform, ownload=True)
# 如果发现下载速度比较慢，可以复制下载链接使用迅雷进行下载，一定程度上可以提高下载速度
# 通过对数据的输出来测试数据是否下载成功以及查看数据的类型
# print(test_set[0])
# # 打印数据的classes属性
# print(test_set.classes)
# img, target = test_set[0]
# print(img)
# print(target)
# print(test_set.classes[target])
# # 展示图片
# img.show()

writer = SummaryWriter("p10")
for i in range(10):
    img, target = test_set[i]
    writer.add_image("test_set". img, i)

注意：如果发现下载速度比较慢，可以复制下载链接使用迅雷进行下载，一定程度上可以提高下载速度。然后根据自己指定的下载路径自己新建一样的文件名，将下载好的数据复制到该文件即可。

同时建议将download参数一直保持设置为True，比较方便。

dataloader

加载器：会将数据加载到神经网络中【例如下面的手中】

官方文档链接：torch.utils.data — PyTorch 2.1 documentation

很多参数多有默认值。

代码学习【dataloader.py】


# 学习dataloader
import torchvision.datasets
# 准备的测试数据集
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

test_data = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor())

# batch_size:每次取多少条数据集 drop_last是否舍去剩下的一点点数据，例如取到最后没有batchsize条数据了
test_loader = DataLoader(dataset=test_data, batch_size=4, shuffle=True, num_workers=0, drop_last=False)

# 测试数据集中第一张图片及target
img, target = test_data[0]
print(img.shape)
print(target)

writer = SummaryWriter("dataloader")

step = 0
# 一次有batchsize条数据 且数据是随机的
for epoch in range(2):  # 学习suffle的作用：决定第二次采样和第一次采样的采样循序是否一样，False：一样；True:会将采样的顺序打乱
    for data in test_loader:
        # imgs targets 是tensor类型
        imgs, targets = data
        print(imgs.shape)
        print(targets)
        writer.add_image("test_data".format(epoch), imgs, step)
        step = step + 1

writer.close()

神经网络的基本骨架——nn.Module的使用

官方文档链接：torch.nn — PyTorch 2.1 documentation

 我们要根据自己的功能填充下面的内容

定义神经网络的模版

  • __init__():初始化__init__():初始化
  • forward():前向传播【当然也有反向传播backword()】

学习代码【nn_module.py】

import torch
from torch import nn

# 定义一个自己的神经网络
# 功能：将输入加一并输出
class Dali(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, input):
        output = input + 1
        return output


dali = Dali()
x = torch.tensor(1.0)
output = dali(x)
print(output)  # tensor(2.)

神经结构的基本使用

卷积层 Convolution Layers

作用：提取图像特征

官方文档链接：torch.nn — PyTorch 2.1 documentation

 2023. 10.31更新【记录一下学习进度，嘿嘿】

卷积操作【选看】

对应官网文档地址：Conv2d — PyTorch 2.1 documentation

界面如下：

计算过程实例：

 Stride = 1:代表横向和纵向每次只挪动一格【也可以根据需要设置成其它的数字】

完整的计算结果实例

代码演示【nn_conv.py】

函数对矩阵的尺寸是有要求的，所以要先进行变换【下面的这个公式比较重要】

import torch
import torch.nn.functional as F

input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]])
kernel = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])
# 查看尺寸
print(input.shape)  # torch.Size([5, 5])
print(kernel.shape)  # torch.Size([3, 3])
# 调整尺寸
input = torch.reshape(input, (1, 1, 5, 5))
kernel = torch.reshape(kernel, (1, 1, 3, 3))
# 查看调整之后的尺寸
print(input.shape)  # torch.Size([1, 1, 5, 5])
print(kernel.shape)  # torch.Size([1, 1, 3, 3])

output = F.conv2d(input,kernel,stride=1)
print(output)

输出结果和前面自己计算的结果是一致的

可以改变参数值，观察输出结果【stride = 1 ——> 2】

output2 = F.conv2d(input,kernel,stride=2)
print(output2)  # tensor([[[[10, 12],[13,  3]]]])

padding参数：

padding默认设置为0，设置为1表示对输入矩阵的四周填充一圈的0

# padding默认设置为0，设置为1表示对输入矩阵的四周填充一圈的0
output3 = F.conv2d(input, kernel, stride=1, padding=1)
print(output3)

 运行结果：

 开始正题【Conv2d】

官方文档地址：Conv2d — PyTorch 2.1 documentation

 nn.Conv2d参数

一般只有设置前五个参数

  • padding:是否在输入矩阵周围填充0
  • stride:横向和纵向每次移动的格数
  • kernel_size:卷积核的大小，其实定义大小就可以了，里面的值不重要，值会随着训练不断变换。
  • In_channel = 1 Out_channel = 1 :说明只有一个卷积核进行计算。如下所示：

In_channel = 2 Out_channel = 2:说明有两个卷积核进行计算并且对应两个计算结果矩阵。如下所示：

 这个链接里面有如下的动图演示：

学习代码【nn_conv2d.py】

import torch
import torchvision

# 准备数据集
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("../data", train= False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)
# 开始搭建自己的神经网络
class Dali(nn.Module):
    def __init__(self):
        super(dali, self).__init__()
        # 增加一个卷积层
        self.conv1 = Conv2d(in_channels=3, out_channels=3, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        x = self.conv1(x)  # 将x放入到卷积层中并把输出结果又赋值给x
        return x
# 初始化网络
dali = Dali()
print(dali)

运行结果

这里是原博主的运行结果，我的网太差了，没有等数据集下载，所以看不到实验结果

将数据集里面的图片进行卷积

# 依次将数据集里面的图片进行卷积
for data in dataloader:
    imgs,targets = data
    output = dali(imgs)
    print(imgs.shape)  # 卷积前的图片尺寸
    print(output.shape)  # 卷积后的图片尺寸

运行结果

 

让结果通过可视化的方式展示，更直观地感受图片的变化
 

# 让结果通过可视化的方式对比展示
writer = SummaryWriter("../logs")
step = 0
for data in dataloader:
    imgs,targets = data
    output = dali(imgs)
    print(imgs.shape)  # 卷积前的图片尺寸
    print(output.shape)  # 卷积后的图片尺寸
    writer.add_image("input", imgs, step)
    # torch.size([64,6,30,30]) -> [xxx,3,30,30]
    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_image("output", output,step)
    step = step + 1

writer.close()
 

 运行结果
 

 

该部分完整的代码如下：
 

import torch
import torchvision

# 准备数据集
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../data", train= False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)
# 开始搭建自己的神经网络
class Dali(nn.Module):
    def __init__(self):
        super(dali, self).__init__()
        # 增加一个卷积层
        self.conv1 = Conv2d(in_channels=3, out_channels=3, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        x = self.conv1(x)  # 将x放入到卷积层中并把输出结果又赋值给x
        return x
# 初始化网络
dali = Dali()
# print(dali)

# 依次将数据集里面的图片进行卷积
# for data in dataloader:
#     imgs,targets = data
#     output = dali(imgs)
#     print(imgs.shape)  # 卷积前的图片尺寸
#     print(output.shape)  # 卷积后的图片尺寸

# 让结果通过可视化的方式对比展示
writer = SummaryWriter("../logs")
step = 0
for data in dataloader:
    imgs,targets = data
    output = dali(imgs)
    print(imgs.shape)  # 卷积前的图片尺寸
    print(output.shape)  # 卷积后的图片尺寸
    writer.add_image("input", imgs, step)
    # torch.size([64,6,30,30]) -> [xxx,3,30,30]
    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_image("output", output,step)
    step = step + 1

writer.close()

 

神经网络——最大池化的使用
 

官方文档地址：torch.nn — PyTorch 2.1 documentation
 

 

MaxPool2d
 

 

 参数信息：
 

 

 dilation:空洞卷积，元素和元素中间空了一个，如下图所示：
 

 

  • return_indices:不常用
  • ceil_mode:两种模式，为True，则保留下列情况的数据；反之则不保留。【默认值为False】
 

 

 

 学习代码【nn_maxpool.py】
 

import torch
from torch import nn
from torch.nn import MaxPool2d

input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]], dtype=torch.float32)  # dtype=torch.float32将数据转换成浮点型
input = torch.reshape(input, (-1, 1, 5, 5))
print(input.shape)  # torch.Size([1, 1, 5, 5])


class Dali(nn.Module):
    def __init__(self):
        super(Dali, self).__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, input):
        output = self.maxpool1(input)
        return output


dali = Dali()
output = dali(input)
print(output)

 

ceil_mode=True的运行结果：
 

tensor([[[[2., 3.],
          [5., 1.]]]])

 

ceil_mode=False的运行结果：
 

tensor([[[[2.]]]])
 

运行结果和前面图片示例中自己手算的结果是一致的。
 

池化层的作用：
 

 

 可视化的方式来观察池化前后的对比：
 

代码
 

import torch
import torchvision

# 准备数据集
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../data", train= False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)
# 开始搭建自己的神经网络
class Dali(nn.Module):
    def __init__(self):
        super(dali, self).__init__()
        # 增加一个卷积层
        self.conv1 = Conv2d(in_channels=3, out_channels=3, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        x = self.conv1(x)  # 将x放入到卷积层中并把输出结果又赋值给x
        return x
# 初始化网络
dali = Dali()
# print(dali)

# 依次将数据集里面的图片进行卷积
# for data in dataloader:
#     imgs,targets = data
#     output = dali(imgs)
#     print(imgs.shape)  # 卷积前的图片尺寸
#     print(output.shape)  # 卷积后的图片尺寸

# 让结果通过可视化的方式对比展示
writer = SummaryWriter("../logs")
step = 0
for data in dataloader:
    imgs,targets = data
    output = dali(imgs)
    print(imgs.shape)  # 卷积前的图片尺寸
    print(output.shape)  # 卷积后的图片尺寸
    writer.add_image("input", imgs, step)
    # torch.size([64,6,30,30]) -> [xxx,3,30,30]
    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_image("output", output,step)
    step = step + 1

writer.close()

 

运行结果
 

池化后的图片比较模糊，但是特征保持得还是比较好的
 

 

 
 
 可以通过池化层大大减少数据量，神经网络必不可少的组成部分
 

 

神经网络——非线性激活（变换）
 

作用：引入非线性特征，可以更好地训练模型，提高模型的泛化能力
 

官方文档地址：https://pytorch.org/docs/stable/nn.html#non-linear-activations-weighted-sum-nonlinearity
 

常用函数举例
 

ReLU
 

官方文档链接:ReLU — PyTorch 2.1 documentation
 

 
  

 


 一种截断函数
 

 
  

 

参数inplace:是否在原来的结果上直接进行替换？一般建议取False,防止数据丢失【默认值是False】
  
 

 
  

 

学习代码【nn_relu.py】 
 

import torch
from torch import nn
from torch.nn import ReLU

input = torch.tensor([[1, -0.5],
                      [-1, 3]])

input = torch.reshape(input, (-1, 1, 2, 2))
print(input.shape)  # torch.Size([1, 1, 2, 2])

class Dali(nn.Module):
    def __init__(self):
        super(Dali, self).__init__()
        self.relu1 = ReLU()

    def forward(self,input):
        output = self.relu1(input)
        return output

dali = Dali()
output = dali(input)
print(output)

 

运行结果： 
 

tensor([[[[1., 0.],
          [0., 3.]]]])
 

Sigmoid
 

官方文档链接:Sigmoid — PyTorch 2.1 documentation
 

 
  

 

 

学习代码【nn_relu.py】
 

 

import torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

input = torch.tensor([[1, -0.5],
                      [-1, 3]])

input = torch.reshape(input, (-1, 1, 2, 2))
print(input.shape)  # torch.Size([1, 1, 2, 2])

dataset = torchvision.datasets.CIFAR10("../data", train= False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)

class Dali(nn.Module):
    def __init__(self):
        super(Dali, self).__init__()
        self.relu1 = ReLU()
        self.sigmoid1 = Sigmoid(input)

    def forward(self,input):
        # output = self.relu1(input)
        output = self.sigmoid1(input)
        return output

dali = Dali()
# output = dali(input)
# print(output)

writer = SummaryWriter("../logs_relu")
step = 0
for data in dataloader:
    imgs, targets = data
    writer.add_image("input", imgs, global_step=step)
    output = dali(imgs)
    writer.add_image("output", output, step)
    step += 1
    
writer.close()
 

运行结果： 
 

 

神经网络——线性层及其他层介绍

                

        

        

    

  


    

      

        

            

              
                
                  小小程序媛(*^▽^*)
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    30
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
Python深度学习入门笔记 2

				
			

			

				

					weixin_49374896的博客
				

				

					01-02
					
					2331
					
				

			

		

		

			
				
介绍深度学习的学习方法，介绍损失函数和误差反向传播法

			
		

	



                

              
                



	

		

			

				
					
Python TypeError: __init__() missing 1 required positional argument 问题

				
			

			

				

					a_sunborui1108的博客
				

				

					03-16
					
					3493
					
				

			

		

		

			
				
这样就会产生TypeError: __init__() missing 1 required positional argument 问题。在这里我们建立了两个变量：b2,c1，而当我们传参时，可能是只付了一个变量的值。当我们学完class还未熟练运用，或做题时可能总会遇到这个问题，那我们该怎么解决呢。而只需要再给c1赋值就可以解决问题了。

			
		

	



                


  
              

                


	

		

			

				
					
《深度学习入门——基于Python的理论与实现》笔记

				
			

			

				

					qq_45445740的博客
				

				

					05-31
					
					6589
					
				

			

		

		

			
				
PS：写这篇博客主要是记录下自己认为重要的部分以及阅读中遇到的些问题，加深印象。
附上电子书及源代码：
链接：https://pan.baidu.com/s/1f2VFcnXSSK-u3wuvgjZ_7Q
提取码：uvbv
《深度学习入门——基于Python的理论与实现》第1章 Python入门1.5.5 广播第2章 感知机2.1 感知机是什么第3章 神经网络第4章 神经网络的学习第5章 误差反向传播法第6章 与学习相关的技巧第7章 卷积神经网络第8章 深度学习
第1章 Python入门
1.5.5 广播


			
		

	





	

		

			

				
					
深度学习入门：基于Python的理论与实现——第一章Python入门

				
			

			

				

					weixin_48396750的博客
				

				

					07-31
					
					3044
					
				

			

		

		

			
				
本文为深度学习入门：基于Python的理论与实现的学习笔记，由于笔者已有matalb、c\c++，java相关语言基础，故只记录不同之处需要注意的地方，供给有其他有语言基础，没学过python但研究方向为机器学习等分支方向的同学参考。...

			
		

	



		

			
		



	

		

			

				
					
[动手学深度学习v2]学习笔记——python中range, list和pytorch tensor的区别

				
			

			

				

					2401_84140519的博客
				

				

					05-06
					
					509
					
				

			

		

		

			
				
现在能在网上找到很多很多的学习资源，有免费的也有收费的，当我拿到1套比较全的学习资源之前，我并没着急去看第1节，我而是去审视这套资源是否值得学习，有时候也会去问一些学长的意见，如果可以之后，我会对这套学习资源做1个学习计划，我的学习计划主要包括规划图和学习进度表。分享给大家这份我薅到的免费视频资料，质量还不错，大家可以跟着学习在李沐老师的【动手学深度学习v2】学习中，在“linear-regression-scratch.ipynb”中遇到了以下代码：产生疑问：为什么要用list(range(…))？

			
		

	





	

		

			

				
					
深度学习鱼书笔记1——python入门

				
			

			

				

					weixin_39657518的博客
				

				

					10-05
					
					454
					
				

			

		

		

			
				
1.该书用到的两个库：matplotlib numpy
2.和数组的算术运算一样,矩阵的算术运算也可以在相同形状的矩阵间以 对应元素 的方式进行.
A = np.array([[1, 2], [3, 4]])
->>> print(A) [[1 2] [3 4]]
B = np.array([[3, 0],[0, 6]])
->>> A + B array([[ 4, 2], [ 3, 10]])
->>> A * B array([[ 3, 0], [

			
		

	





	

		

			

				
					
深度学习入门：基于Python的理论与实现③

				
			

			

				

					qq_61879501的博客
				

				

					10-21
					
					1330
					
				

			

		

		

			
				
有关深度学习的学习笔记（包括CNN）

			
		

	





	

		

			

				
					
深度学习入门：基于Python的理论与实现

				
			

			

				

					weixin_43845922的博客
				

				

					09-20
					
					1605
					
				

			

		

		

			
				
python

			
		

	





	

		

			

				
					
深度学习入门：基于Python的理论与实现②

				
			

			

				

					qq_61879501的博客
				

				

					10-12
					
					1563
					
				

			

		

		

			
				
学习笔记②

			
		

	





	

		

			

				
					
【学习笔记】深度学习入门：基于Python的理论与实现-神经网络

				
			

			

				

					一只快乐的小蒟蒻~
				

				

					12-01
					
					1686
					
				

			

		

		

			
				
【学习笔记】深度学习入门：基于Python的理论与实现-神经网络

			
		

	





	

		

			

				
					
深度学习（基于Tensorflow2.0）学习笔记——Day2

				
			

			

				

					01-20
				

			

		

		

			
				
本篇学习笔记主要关注如何在Tensorflow2.0环境下开始深度学习的学习和实践。  【深度学习基础知识回顾】  在开始实战前，对深度学习的基础知识进行回顾是必要的。这包括神经网络的基本概念、反向传播算法、损失函数...

			
		

	





	

		

			

				
					
学习笔记：深度学习（3）——卷积神经网络（CNN）理论篇

					
热门推荐

				
			

			

				

					Morganfs的博客
				

				

					04-12
					
					10万+
					
				

			

		

		

			
				
深度学习笔记——CNN卷积神经网络理论篇。主要包括CNN的概念、基本原理、类型综述。算是比较完善的一篇文章了。


			
		

	





	

		

			

				
					
Python基础 5 - 类、对象、注解

				
			

			

				

					云端梦留白的博客
				

				

					09-04
					
					1382
					
				

			

		

		

			
				
面向对象（Object-Oriented, OOP）是一种编程范式，它使用“对象”来设计软件，这些对象包含数据（通常称为属性或字段）和代码（通常称为方法或函数），以模拟现实世界实体的属性和行为。面向对象是一种编程方法，通过创建包含数据和行为的对象来模拟现实世界，提高代码的组织性、重用性和灵活性。在 Pyhon 中，想要使用类，必须先创建对象。class 类名称 : # class 关键字，表示定义了一个类，类首字符大写为标准。

			
		

	





	

		

			

				
					
JS都有哪些操作数组的方法

				
			

			

				

					ggq53219的博客
				

				

					09-04
					
					558
					
				

			

		

		

			
				
JavaScript 中操作数组的方法非常丰富，这些方法大致可以分为几类：创建和初始化数组、添加元素、删除元素、遍历数组、搜索元素、数组排序、数组映射和过滤等。

			
		

	





	

		

			

				
					
pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定

					
最新发布

				
			

			

				

					weixin_53707653的博客
				

				

					09-09
					
					481
					
				

			

		

		

			
				
是一个强大且易用的工具，可以帮助开发者轻松管理 Python 项目的依赖关系，确保代码的可重复性和稳定性。是一组命令行工具，旨在简化 Python 依赖关系的管理，确保项目环境的稳定性和可重复性。可以确保每次构建环境时都使用相同的依赖项版本，从而避免由于依赖项版本不一致导致的错误，提高代码可重复性和稳定性。自动化了依赖关系管理过程，节省了开发者的时间和精力，可以将更多时间投入到实际的开发工作中。文件中的信息，更新虚拟环境，安装、升级或卸载所需的软件包，确保虚拟环境与。命令可以从你的项目配置文件中生成。

			
		

	





	

		

			

				
					
mongodb在Java中条件分组聚合查询并且分页(时间戳，按日期分组，年月日...)

				
			

			

				

					简单发点工作中用到的，或者记录下小知识点
				

				

					09-03
					
					1779
					
				

			

		

		

			
				
按时间 年月日条件分组，筛选数据，统计数据，聚合查询
打印出mongo的SQL语句

			
		

	





	

		

			

				
					
Transiting from CUDA to HIP （二）

				
			

			

				

					weixin_44500921的博客
				

				

					09-03
					
					1335
					
				

			

		

		

			
				
为了解决这个问题，HIP（Heterogeneous-compute Interface for Portability）提供了一套宏定义，使得开发者可以编写可移植的代码，这些代码可以在 NVIDIA 的 CUDA 平台和 AMD 的 ROCm 平台上运行。是一个预定义的宏，用于指示当前编译的代码所针对的 NVIDIA GPU 的计算能力（Compute Capability）。为了正确编译包含 HIP 代码的文件，您需要确保编译器能够找到 HIP 的头文件，并且定义了正确的宏。

			
		

	





	

		

			

				
					
asyncio note

				
			

			

				

					weixin_48232453的博客
				

				

					09-03
					
					873
					
				

			

		

		

			
				
python异步库asyncio入门

			
		

	





	

		

			

				
					
【hot100篇-python刷题记录】【数据流的中位数】

				
			

			

				

					m0_73629042的博客
				

				

					09-04
					
					354
					
				

			

		

		

			
				
精简的代码总是难以琢磨。

			
		

	





	

		

			

				
					
人工智能入门：从机器学习到深度学习笔记

				
			

			

				

					
				

			

		

		

			
				
"这是一份关于机器学习和深度学习的学习笔记，适合初学者，内容包括人工智能的基本概念、开发环境的搭建、基础工具包的使用以及Jupyter Notebook的界面优化和编码入门。"  在这份笔记中，作者首先介绍了人工智能的两...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值