深度学习--PyTorch框架

最新推荐文章于 2025-08-24 21:33:16 发布

原创最新推荐文章于 2025-08-24 21:33:16 发布 · 711 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#深度学习 #pytorch #人工智能

深度学习专栏收录该内容

2 篇文章

订阅专栏

一·理论讲解

pytorch往下可以分成

CPU 版本
CPU 又称中央处理器，作为计算机系统的运算和控制核心，是信息处理、程序运行的最终执行单元。可以形象地理解为有 25% 的 ALU (运算单元)、有 25% 的 Control (控制单元)、50% 的 Cache (缓存) 单元。ROM是内存条是配合CPU的

GPU 版本
GPU 又称图像处理器，是一种专门在个人电脑等一些移动设备上做图像和图形相关运算工作的微处理器。可以形象地理解为 90% 的 ALU (运算单元)，5% 的 Control (控制单元)、5% 的 Cache (缓存)。

显卡重要参数：
显存容量：决定着临时存储数据的能力，6GB、8GB、24GB、48GB
显存频率：反应显存的速度，1600MHz、1800MHz、3800MHz、5000MHz 等
显存位宽：一个时钟周期内所能传送数据的位数，64、128、192、256、384、448、512。
英伟达显卡√

二·如何下载pytorch

任务管理器查看自己电脑的性能

看自己电脑最高支持的版本

CUDA安装教程（超详细）-CSDN博客

按步骤去做到环境变量那里停不管了后面回来

按这个步骤，然后下面我们说5

以下是PY3.7版本的，其他版本的可以问问大语言模型

ctrl+F是调出搜索框的命令

这三个找个文件夹放着比如文件夹A

然后打开终端分别

就好了

pip install D:\download\pytorch\torch-1.13.1+cu117-cp37-cp37m-win_amd64.whl

说明，这个D:\download\pytorch\是文件夹A的地址，后面的就是这个图片你下载好后文件全名称

三·代码

逻辑思维图

import torch
print(torch.__version__)  # 验证安装的开发环境是否正确

'''
MNIST 包含 70,000 张手写数字图像；60,000 张用于训练，10,000 张用于测试。
图像是灰度的，28x28 像素的，并且居中的，以减少预处理和加快运行。
'''

import torch
from torch import nn  # 导入神经网络模块
from torch.utils.data import DataLoader  # 数据管理工具，打包数据
from torchvision import datasets  # 封装了很多与图像相关的模型、及数据集
from torchvision.transforms import ToTensor  # 数据转换、张量，将其他类型的数据转换为 tensor 张量，numpy array, dataframe

'''下载训练数据集（包含训练图片 + 标签）'''
training_data = datasets.MNIST(  # 跳转到函数内部源代码，pycharm 按 Ctrl + 鼠标点击
    root="data",  # 表示下载的手写数字，到哪个路径，.60000
    train=True,  # 表示下载后的数据集，里的，训练集
    download=True,  # 如果你之前已经下载过了，就不用再下载
    transform=ToTensor()  # 张量，图片是不能直接传入神经网络模型
)  # 对于 pytorch 来说能够识别的数据一般是 tensor 张量

'''下载测试数据集（包含训练图片 + 标签）'''
test_data = datasets.MNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()  # Tensor 是在深度学习中被使用广泛的数据类型，它为深度学习框架（如 PyTorch、TensorFlow）紧密集成，方便进行神经网络的训练和推理。
)  # 允许 CPU 和 GPU 运行，Tensor 可以在 GPU 上运行，这在深度学习应用中可以显著提升计算速度。

print(len(training_data))

'''展示手写数字图片，把训练数据集中的前 59000 张图片展示一下'''

from matplotlib import pyplot as plt

figure = plt.figure()
for i in range(9):
    img, label = training_data[i + 59000]  # 提取第 59000 张图片
    figure.add_subplot(3, 3, i + 1)  # 图像窗口中创建多个小窗口、小窗口用于展示图片
    plt.title(label)
    plt.axis("off")  # plt.show() 才显示矢量
    plt.imshow(img.squeeze(), cmap="gray")  # plt.imshow() 函数来将数组（data）中的数据显示为图像，并在图形窗口中显示图像
a = img.squeeze()  # img.squeeze() 从张量 img 中去掉维度为 1 的，如果该维度的大小不为 1 则张量不会改变。cmap="gray" 表示使用灰度色彩映射来显示图像，这意味着图像将以灰度模式显示
plt.show()

代码的讲解

训练集

import torch
print(torch.__version__)  # 验证安装的开发环境是否正确

'''
MNIST 包含 70,000 张手写数字图像；60,000 张用于训练，10,000 张用于测试。
图像是灰度的，28x28 像素的，并且居中的，以减少预处理和加快运行。
'''

import torch
from torch import nn  # 导入神经网络模块
from torch.utils.data import DataLoader  # 数据管理工具，打包数据
from torchvision import datasets  # 封装了很多与图像相关的模型、及数据集
from torchvision.transforms import ToTensor  # 数据转换、张量，将其他类型的数据转换为 tensor 张量，numpy array, dataframe

torch数据叫张量类型的数据，只能把ToTensor类型的数据转到GPU里面训练，

from torchvision import datasets  # 封装了很多与图像相关的模型、及数据集

'''下载训练数据集（包含训练图片 + 标签）'''
training_data = datasets.MNIST(  # 跳转到函数内部源代码，pycharm 按 Ctrl + 鼠标点击
    root="data",  # 表示下载的手写数字，到哪个路径，.60000
    train=True,  # 表示下载后的数据集，里的，训练集
    download=True,  # 如果你之前已经下载过了，就不用再下载
    transform=ToTensor()  # 张量，图片是不能直接传入神经网络模型
)  # 对于 pytorch 来说能够识别的数据一般是 tensor 张量

  transform=ToTensor()  # 张量，图片是不能直接传入神经网络模型
)  # 对于 pytorch 来说能够识别的数据一般是 tensor 张量

这个就是把所有类型的数据转换成ToTensor的类型（底层是numpy处理的）

只有data是我们的关键数据，下面也可以看到train_labels标签，train_data和data是一样的原因是

 train=True,  # 表示下载后的数据集，里的，训练集

测试集

'''下载测试数据集（包含训练图片 + 标签）'''
test_data = datasets.MNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()  # Tensor 是在深度学习中被使用广泛的数据类型，它为深度学习框架（如 PyTorch、TensorFlow）紧密集成，方便进行神经网络的训练和推理。
)  # 允许 CPU 和 GPU 运行，Tensor 可以在 GPU 上运行，这在深度学习应用中可以显著提升计算速度。

可以看出来这里是一类的只不过train=False，

MNIST类

class MNIST(VisionDataset):
    """`MNIST <http://yann.lecun.com/exdb/mnist/>`_ Dataset.

    Args:
        root (string): Root directory of dataset where ``MNIST/raw/train-images-idx3-ubyte``
            and  ``MNIST/raw/t10k-images-idx3-ubyte`` exist.
        train (bool, optional): If True, creates dataset from ``train-images-idx3-ubyte``,
            otherwise from ``t10k-images-idx3-ubyte``.
        download (bool, optional): If True, downloads the dataset from the internet and
            puts it in root directory. If dataset is already downloaded, it is not
            downloaded again.
        transform (callable, optional): A function/transform that  takes in an PIL image
            and returns a transformed version. E.g, ``transforms.RandomCrop``
        target_transform (callable, optional): A function/transform that takes in the
            target and transforms it.
    """

    mirrors = [
        "http://yann.lecun.com/exdb/mnist/",
        "https://ossci-datasets.s3.amazonaws.com/mnist/",
    ]

    resources = [
        ("train-images-idx3-ubyte.gz", "f68b3c2dcbeaaa9fbdd348bbdeb94873"),
        ("train-labels-idx1-ubyte.gz", "d53e105ee54ea40749a09fcbcd1e9432"),
        ("t10k-images-idx3-ubyte.gz", "9fb629c4189551a2d022fa330f9573f3"),
        ("t10k-labels-idx1-ubyte.gz", "ec29112dd5afa0611ce80d1b7f02629c"),
    ]

    training_file = "training.pt"
    test_file = "test.pt"
    classes = [
        "0 - zero",
        "1 - one",
        "2 - two",
        "3 - three",
        "4 - four",
        "5 - five",
        "6 - six",
        "7 - seven",
        "8 - eight",
        "9 - nine",
    ]

    @property
    def train_labels(self):
        warnings.warn("train_labels has been renamed targets")
        return self.targets

    @property
    def test_labels(self):
        warnings.warn("test_labels has been renamed targets")
        return self.targets

    @property
    def train_data(self):
        warnings.warn("train_data has been renamed data")
        return self.data

    @property
    def test_data(self):
        warnings.warn("test_data has been renamed data")
        return self.data

    def __init__(
        self,
        root: str,
        train: bool = True,
        transform: Optional[Callable] = None,
        target_transform: Optional[Callable] = None,
        download: bool = False,
    ) -> None:
        super().__init__(root, transform=transform, target_transform=target_transform)
        self.train = train  # training set or test set

        if self._check_legacy_exist():
            self.data, self.targets = self._load_legacy_data()
            return

        if download:
            self.download()

        if not self._check_exists():
            raise RuntimeError("Dataset not found. You can use download=True to download it")

        self.data, self.targets = self._load_data()

    def _check_legacy_exist(self):
        processed_folder_exists = os.path.exists(self.processed_folder)
        if not processed_folder_exists:
            return False

        return all(
            check_integrity(os.path.join(self.processed_folder, file)) for file in (self.training_file, self.test_file)
        )

    def _load_legacy_data(self):
        # This is for BC only. We no longer cache the data in a custom binary, but simply read from the raw data
        # directly.
        data_file = self.training_file if self.train else self.test_file
        return torch.load(os.path.join(self.processed_folder, data_file))

    def _load_data(self):
        image_file = f"{'train' if self.train else 't10k'}-images-idx3-ubyte"
        data = read_image_file(os.path.join(self.raw_folder, image_file))

        label_file = f"{'train' if self.train else 't10k'}-labels-idx1-ubyte"
        targets = read_label_file(os.path.join(self.raw_folder, label_file))

        return data, targets

    def __getitem__(self, index: int) -> Tuple[Any, Any]:
        """
        Args:
            index (int): Index

        Returns:
            tuple: (image, target) where target is index of the target class.
        """
        img, target = self.data[index], int(self.targets[index])

        # doing this so that it is consistent with all other datasets
        # to return a PIL Image
        img = Image.fromarray(img.numpy(), mode="L")

        if self.transform is not None:
            img = self.transform(img)

        if self.target_transform is not None:
            target = self.target_transform(target)

        return img, target

    def __len__(self) -> int:
        return len(self.data)

    @property
    def raw_folder(self) -> str:
        return os.path.join(self.root, self.__class__.__name__, "raw")

    @property
    def processed_folder(self) -> str:
        return os.path.join(self.root, self.__class__.__name__, "processed")

    @property
    def class_to_idx(self) -> Dict[str, int]:
        return {_class: i for i, _class in enumerate(self.classes)}

    def _check_exists(self) -> bool:
        return all(
            check_integrity(os.path.join(self.raw_folder, os.path.splitext(os.path.basename(url))[0]))
            for url, _ in self.resources
        )

    def download(self) -> None:
        """Download the MNIST data if it doesn't exist already."""

        if self._check_exists():
            return

        os.makedirs(self.raw_folder, exist_ok=True)

        # download files
        for filename, md5 in self.resources:
            for mirror in self.mirrors:
                url = f"{mirror}{filename}"
                try:
                    print(f"Downloading {url}")
                    download_and_extract_archive(url, download_root=self.raw_folder, filename=filename, md5=md5)
                except URLError as error:
                    print(f"Failed to download (trying next):\n{error}")
                    continue
                finally:
                    print()
                break
            else:
                raise RuntimeError(f"Error downloading {filename}")

    def extra_repr(self) -> str:
        split = "Train" if self.train is True else "Test"
        return f"Split: {split}"

datasets

from ._optical_flow import FlyingChairs, FlyingThings3D, HD1K, KittiFlow, Sintel
from ._stereo_matching import (
    CarlaStereo,
    CREStereo,
    ETH3DStereo,
    FallingThingsStereo,
    InStereo2k,
    Kitti2012Stereo,
    Kitti2015Stereo,
    Middlebury2014Stereo,
    SceneFlowStereo,
    SintelStereo,
)
from .caltech import Caltech101, Caltech256
from .celeba import CelebA
from .cifar import CIFAR10, CIFAR100
from .cityscapes import Cityscapes
from .clevr import CLEVRClassification
from .coco import CocoCaptions, CocoDetection
from .country211 import Country211
from .dtd import DTD
from .eurosat import EuroSAT
from .fakedata import FakeData
from .fer2013 import FER2013
from .fgvc_aircraft import FGVCAircraft
from .flickr import Flickr30k, Flickr8k
from .flowers102 import Flowers102
from .folder import DatasetFolder, ImageFolder
from .food101 import Food101
from .gtsrb import GTSRB
from .hmdb51 import HMDB51
from .imagenet import ImageNet
from .inaturalist import INaturalist
from .kinetics import Kinetics
from .kitti import Kitti
from .lfw import LFWPairs, LFWPeople
from .lsun import LSUN, LSUNClass
from .mnist import EMNIST, FashionMNIST, KMNIST, MNIST, QMNIST
from .omniglot import Omniglot
from .oxford_iiit_pet import OxfordIIITPet
from .pcam import PCAM
from .phototour import PhotoTour
from .places365 import Places365
from .rendered_sst2 import RenderedSST2
from .sbd import SBDataset
from .sbu import SBU
from .semeion import SEMEION
from .stanford_cars import StanfordCars
from .stl10 import STL10
from .sun397 import SUN397
from .svhn import SVHN
from .ucf101 import UCF101
from .usps import USPS
from .vision import VisionDataset
from .voc import VOCDetection, VOCSegmentation
from .widerface import WIDERFace

__all__ = (
    "LSUN",
    "LSUNClass",
    "ImageFolder",
    "DatasetFolder",
    "FakeData",
    "CocoCaptions",
    "CocoDetection",
    "CIFAR10",
    "CIFAR100",
    "EMNIST",
    "FashionMNIST",
    "QMNIST",
    "MNIST",
    "KMNIST",
    "StanfordCars",
    "STL10",
    "SUN397",
    "SVHN",
    "PhotoTour",
    "SEMEION",
    "Omniglot",
    "SBU",
    "Flickr8k",
    "Flickr30k",
    "Flowers102",
    "VOCSegmentation",
    "VOCDetection",
    "Cityscapes",
    "ImageNet",
    "Caltech101",
    "Caltech256",
    "CelebA",
    "WIDERFace",
    "SBDataset",
    "VisionDataset",
    "USPS",
    "Kinetics",
    "HMDB51",
    "UCF101",
    "Places365",
    "Kitti",
    "INaturalist",
    "LFWPeople",
    "LFWPairs",
    "KittiFlow",
    "Sintel",
    "FlyingChairs",
    "FlyingThings3D",
    "HD1K",
    "Food101",
    "DTD",
    "FER2013",
    "GTSRB",
    "CLEVRClassification",
    "OxfordIIITPet",
    "PCAM",
    "Country211",
    "FGVCAircraft",
    "EuroSAT",
    "RenderedSST2",
    "Kitti2012Stereo",
    "Kitti2015Stereo",
    "CarlaStereo",
    "Middlebury2014Stereo",
    "CREStereo",
    "FallingThingsStereo",
    "SceneFlowStereo",
    "SintelStereo",
    "InStereo2k",
    "ETH3DStereo",
)

图片

from matplotlib import pyplot as plt

figure = plt.figure()
for i in range(9):
    img, label = training_data[i + 59000]  # 提取第 59000 张图片
    figure.add_subplot(3, 3, i + 1)  # 图像窗口中创建多个小窗口、小窗口用于展示图片
    plt.title(label)
    plt.axis("off")  # plt.show() 才显示矢量
    plt.imshow(img.squeeze(), cmap="gray")  # plt.imshow() 函数来将数组（data）中的数据显示为图像，并在图形窗口中显示图像
a = img.squeeze()  # img.squeeze() 从张量 img 中去掉维度为 1 的，如果该维度的大小不为 1 则张量不会改变。cmap="gray" 表示使用灰度色彩映射来显示图像，这意味着图像将以灰度模式显示
plt.show()

figure.add_subplot(3, 3, i + 1)  # 图像窗口中创建多个小窗口、小窗口用于展示图片

squeeze，可以降维

DataLoader数据管理工具

# '''创建数据DataLoader（数据加载器）
#     batch_size:将数据集分成多份，每一份为batch_size个数据。
#           优点：可以减少内存的使用，提高训练速度。
# '''

train_dataloader = DataLoader(training_data, batch_size=64)#64张图片为一个包，
test_dataloader = DataLoader(test_data, batch_size=64)
# for X, y in test_dataloader:#X是表示打包好的每一个数据包
#     print(f"Shape of X [N, C, H, W]: {X.shape}")#
#     print(f"Shape of y: {y.shape} {y.dtype}")
#     break

DataLoader数据管理工具,batch_size是批次数据量

2G的内容分32\64\批次传，

批量梯度下降法（Batch Gradient Descent）BGD
使用全样本数据计算梯度，例如一个 batch_size=64，计算出 64 个梯度值
好处：收敛次数少。坏处：每次迭代需要用到所有数据，占用内存大耗时大。
随机梯度下降法（Stochastic Gradient Descent）
从 64 个样本中随机抽出一组，训练后按梯度更新一次
优点：速度快。缺点：可能陷入局部最优，搜索起来比较盲目，并不是每次都朝着最优的方向

这里我们为了找到最小点，会随机投很多点

求得的公式会一批次更新一次w权重，一个批次的平均损失函数
小批量梯度下降法（Mini-batch Gradient Descent）
将训练数据集分成小批量用于计算模型误差和更新模型参数。是批量梯度下降法和随机梯度下降法的结合。
自适应矩估计 (Adaptive Moment Estimation) Adam
动量梯度下降（Momentum Gradient Descent）
AdaGrad
RMSprop
AdamW
Adadelta

在传递图片的过程IO操作中很耗费时间

# 判断当前设备是否支持GPU，其中mps是苹果m系列芯片的GPU。 '''#返回cuda, mps. CPU  m1 , m2  菜显CPU+GPU RTX3060,
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")#字符串的格式化。  CUDA驱动软件的功能: pytorch能够去执行cuda的命令, cuda通过GPU指令集去控制GPU
# #神经网络的模型也需传入到GPU，1个batchsize的数据集也需要传入到GPU，才可以进行训练。

cuda看是否存在，存在就返回，不存在就else看mps是苹果的算力m1和m2

任务一完成了

任务二如何搭建网络

from torch import nn  # 导入神经网络模块

''' 定义神经网络  类的继承这种方式'''
class NeuralNetwork(nn.Module):#通过调用类的形式来使用神经网络，神经网络的模型，nn.module
    def __init__(self):#python基础关于类,self类自己本身
        super().__init__()#继承的父类初始化
        self.flatten = nn.Flatten()#展开,创建一个展开对象flatten
        self.hidden1 = nn.Linear(28*28, 128)#第1个参数：有多少个神经元传入进来，第2个参数：有多少个数据传出去前一层神经元的个数，当前本
        self.hidden2 = nn.Linear(128, 256)#为什么你要用128 
        self.out = nn.Linear(256, 10)#输出必需和标签的类别相同，输入必须是上一层的神经元个数
    def forward(self, x):  #前向传播，你得告诉它  数据的流向。是神经网络层连接起来，函数名称不能改。当你调用forward函数的时候，传入进来的
        x = self.flatten(x)      #图像进行展开
        x = self.hidden1(x)
        x = torch.relu(x) #激活函数，torch使用的relu函数 relu，tanh
        x = self.hidden2(x)
        x = torch.relu(x)
        x = self.out(x)
        return x

通过类来搭建的，四行分别对应4层网络