由浅入深，走进深度学习（1）

今天不想Debug

已于 2024-06-20 20:35:49 修改

阅读量235

点赞数 3

文章标签： python pillow conda

于 2024-06-20 00:13:18 首次发布

本文链接：https://blog.csdn.net/weixin_45325693/article/details/139815356

版权

本次内容主要是和大家分享，一起学习深度学习相关知识

需要使用到的相关库有Pytorch（最好是gpu，如果没有gpu那就使用cpu的）

一共包含五小节内容，主要使用到的库有：Pillow、torch、torchvision、opencv-python

在这里我把torch安装教程放在这里啦，还是比较详细的，大家可以根据教程安装一下：

深度学习！！PyTorch框架安装！！（手把手教你，如何配置对应版本CUDA cudnn 虚拟环境以及怎么同意安装包）_pip安装的torch包如何链接到安装的指定cuda-CSDN博客

如果大家觉得安装包比较慢的话，可以用镜像源加速一下：

Anaconda、CUDA、cudnn常见问题，已经注意事项总结！！-CSDN博客

正片开始：

内容一：数据加载

在这里的数据加载，就有两种方式可以选择：直接加载（Pillow），或者使用Pytorch加载

①直接加载

直接加载很简单，代码如下：

from PIL import Image

img_path = 'data\1.jpg'
img = Image.open(img_path)
img.show()

②使用torch加载数据

代码如下：

import torch
from torch.utils.data import Dataset
form PIL import Image
import os

class Mydataset(Dataset):
    def __init__(self,root_path,label_path):
        self.root_path = root_path
        self.label_patn = label_path
        self.path = os.path.join(self.root_path,self.label.path) # 拼接，路径：root_path/label_path
        self.img_path = os.listdir(self.path) # 该路径下所有图片
    
    def __getitem__(self,idx):
        self.img_name = self.img_path[idx]
        self.img_item_path = os.path.join(self.root_path,self.label,self.img_name)
        img = Image.open(img_item_path)
        label = label_path
        return img,label

    def __len__(self):
        return len(self.img_name)

root_path = ''
label_path = ''
dataset = Mydataset(root_path,label_path)
print(len(dataset))
img, label = dataset[0]
print(‘label’, label)
img.show

内容二：transforms使用，包括归一化和裁剪的一些方法

from torchvision import transforms
from PIL import Image

img_path = 'data/img/001001.png'
img = Image.open(img_path)

tensor_transfor = transforms.ToTensor()
tensor_img = tensor_transfor(img)
print(tensor_img.shape)
print(tensor_img)

归一化：

# 归一化
from torchvision import transforms
from PIL import Image
import cv2

img_path = 'data/1.jpg'
img = Image.open(img_path)

tensor_trans = transforms.ToTensor()
img_tensor = tensor_trans(img)

print(img_tensor.shape)
print(img_tensor)

print(img_tensor[0][0][0]) # 打印第一个张量

img_RGB = Image.open(img_path).convert('RGB') # 如果不是RGB 三个通道转为三个通道格式
tensor_img_RGB = tensor_trans(img_RGB)
print(tensor_img_RGB.shape)
print(tensor_img_RGB)

tensor_norm = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) #input[channel]=(input[chnnel]-mean[channel])/std[channel]
# # transforms.Normalize(mean, std)
img_norm = tensor_norm(tensor_img_RGB)
print(img_norm)
print(img_norm[0][0][0])

# Resize裁剪 方法一
from torchvision import transforms
from PIL import Image
import cv2

img_path = 'data/1.jpg'
img = Image.open(img_path)
print(img)

tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)
print(tensor_img.shape)

trans_size = transforms.Resize((512, 512))
# PIL数据类型的 img -> resize -> PIL数据类型的 img_resize
resize_img = trans_size(img)
# PIL 数据类型的 PIL -> totensor -> img_resize tensor
tensor_resize_img = tensor_trans(resize_img)
print(resize_img)
print(tensor_resize_img.size())
print(tensor_resize_img.shape)

# Resize裁剪 方法二
from torchvision import transforms
from PIL import Image
import cv2

img_path = 'data/1.jpg'
img = Image.open(img_path)
print(img)

tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)
print(tensor_img.shape)

# 等比缩放
trans_size = transforms.Resize(512) # 将图像的较短边调整为 512 像素，保持宽高比不变。对于较长边，将根据原始宽高比进行相应的调整
# PIL类型的 Image -> resize -> PIL类型的 Image -> totensor -> tensor类型的 Image
trans_compose = transforms.Compose([trans_size, tensor_trans]) # Compose函数中后面一个参数的输入为前面一个参数的输出
# trans_compose 是一个组合变换，由 trans_size 和 tensor_trans 两个变换操作按顺序组成
# 首先对图像进行调整大小，然后将调整大小后的图像转换为张量
resize_img = trans_compose(img)

print(resize_img)
print(resize_img.size())
print(resize_img.shape)

# RandomCrop 随机裁剪
from torchvision import transforms
from PIL import Image
import cv2

img_path = 'data/1.jpg'
img = Image.open(img_path)

tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)

trans_random = transforms.RandomCrop(512) # 随机裁剪成512×512
trans_compose = transforms.Compose([trans_random, tensor_trans])
for i in range(10):
    img_crop = trans_compose(img)
    print(img_crop.size())

# RandomCrop 随机裁剪,指定裁剪尺寸
from torchvision import transforms
from PIL import Image
import cv2

img_path = 'data/1.jpg'
img = Image.open(img_path)

tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)

trans_random = transforms.RandomCrop((645,888)) # 指定裁剪尺寸
trans_compose = transforms.Compose([trans_random, tensor_trans])
for i in range(10):
    img_crop = trans_compose(img)
    print(img_crop.size())

内容三：数据集的一些简单使用，包括加载数据集，查看数据集等等

import torchvision
train_dataset = torchvision.datasets.CIFAR10(root = "dataset", train = True, download = True)
test_dataset = torchvision.datasets.CIFAR10(root = 'dataset', train = False, download = True)
# root为存放数据集的相对路线, train=True是训练集，train=False是测试集

print(test_dataset[0], test_dataset[5]) # 输出的3, 6是target 
print(test_dataset.classes) # 测试数据集中有多少种

img, target = test_dataset[0] #
print(img, target)

print(test_dataset.classes[target])
img.show

内容四：如何使用数据加载

import torchvision
from torch.utils.data import DataLoader

test_dataset = torchvision.datasets.CIFAR10(root = 'dataset', train = False, download = True, transform = torchvision.transforms.ToTensor())
img, target = test_dataset[0]
print(img.shape)
print(img)

# batch_size=4 使得 img0, target0 = dataset[0]、img1, target1 = dataset[1]、img2, target2 = dataset[2]、img3, target3 = dataset[3]
# 然后这四个数据作为Dataloader的一个返回     
test_loader = DataLoader(dataset = test_dataset, batch_size = 4, shuffle = True, num_workers = 0, drop_last = False)
for data in test_loader:
    img, targets = data
    print(img.shape)
    print(targets)

import torchvision
from torch.utils.data import DataLoader

test_dataset = torchvision.datasets.CIFAR10(root = 'dataset', train = False, download = True, transform = torchvision.transforms.ToTensor())
# img, target = test_dataset[0]
# print(img.shape)
# print(img)

# batch_size=4 使得 img0, target0 = dataset[0]、img1, target1 = dataset[1]、img2, target2 = dataset[2]、img3, target3 = dataset[3]
# 然后这四个数据作为Dataloader的一个返回     
test_loader = DataLoader(dataset = test_dataset, batch_size = 64, shuffle = True, num_workers = 0, drop_last = False)
for epoch in range(2):
    step = 0
    for data in test_loader:
        img, targets = data # 每个data都是由4张图片组成，imgs.size 为 [4,3,32,32]，四张32×32图片三通道，targets由四个标签组成 
        # print("Epoch：{}".format(epoch), img, step)
        print(img.shape)
        print(targets)
        step = step + 1

内容五：nn.Module模块的一些简单使用方法

import torch
from torch import nn

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()   # 继承父类的初始化
        
    def forward(self, input):   # 将forward函数进行重写
        output = input + 1
        return output

model = MyModule()
# x = torch.tensor(1.0)   # 创建一个值为 1.0 的tensor
x = [3, 32, 32]
x = torch.tensor(x)  # 转为tensor形式
output = model(x)
print(output)
print(output.shape)


# 因为 PyTorch 中的大部分方法都继承自 torch.nn.Module
# 而 torch.nn.Module 的__call__(self)函数中会返回 forward()函数 的结果
# 因此PyTroch中的 forward()函数等于是被嵌套在了__call__(self)函数中
# 因此forward()函数可以直接通过类名被调用，而不用实例化对象
import torch
from torch import nn

class mymodel(nn.Module):
    def __call__(self, input):
        print('this can be called a function')
        print('the type of input is: {}, the value is {}'.format(type(input), input))
        res = self.forward(input)
        return res

    def forward(self, input_):
        print('forward function is used in call')
        print('in forward, the type of input is: {}, the value is {}'.format(type(input_), input_))
        return input_

model = mymodel()
input_1 = model('a') 
print(input_1)

注：上述内容参考b站up主“我是土堆”的视频！！！