pycharm系统学习记录更新(小土堆)

qq_39419131

已于 2022-09-13 09:48:30 修改

阅读量591

点赞数 2

分类专栏： pycharm学习记录文章标签： pycharm 学习 python

于 2022-09-09 15:43:24 首次发布

本文链接：https://blog.csdn.net/qq_39419131/article/details/126780442

版权

pycharm学习记录专栏收录该内容

1 篇文章 0 订阅

订阅专栏

数据处理

一、数据读取

from torch.utils.data  import Dataset
from PIL import Image
import os
import numpy as np
#子类继承父类
# class Person(object):
# # 初始化
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#     def info(self):
#         print(self.name,self.age)
#
# class Student(Person):
#     def __init__(self,name,age,stu_no):
#         super().__init__(name,age)
#         self.stu_no=stu_no
# #类实例化
# stu=Student('james',30,'23')
# stu.info()

class MyDataset(Dataset):
    def __init__(self,root_dir,label_dir):
        self.root_dir=root_dir
        self.label_dir = label_dir
        #路径拼接 用相对地址 绝地地址会出错
        self.path=os.path.join(self.root_dir,self.label_dir)
        #将路径变成目录列表形式 listdir：文件夹下东西变成列表
        self.img_path=os.listdir(self.path)

 #使用dataset 重写 getitem len 方法
 #获取图片列表 在通过索引去获取图片地址
    def __getitem__(self, idx):
        image_name=self.img_path[idx]
        image_item_path=os.path.join(self.root_dir,self.label_dir,image_name)
        label=self.label_dir
        img=Image.open(image_item_path)
        return  img,label

#获取图片列表长度
    def __len__(self):
        return len(self.img_path)


ants_label_dir=r'ants'
bees_label_dir=r'bees'
root_dir=r'hymenoptera_data/train'
ants_dataset=MyDataset(root_dir,ants_label_dir)
bees_dataset=MyDataset(root_dir,bees_label_dir)
# img,label=dataset[0]
# label=dataset[1]

train_dataset=ants_dataset+bees_dataset

二、tansforms

from PIL import Image
from tensorboardX import SummaryWriter
from torchvision import transforms

img_path=r'F:\programming study\hymenoptera_data\train\ants\0013035.jpg'
img=Image.open(img_path)

writer = SummaryWriter("logs")

#to tensor

#transformers 直接使用
#初始化实例化 jerry = Person() 会自动调用__init__方法。这个方法第一个形式参数必须留给self，其它参数随意
tensor_trans=transforms.ToTensor()
#传入参数 由于 transform里的call方法 __ call __:   触发时机:将对象当做函数调用的时候自动触发
img_tensor=tensor_trans(img)
print(img_tensor[0][0][0])
#normaize 均值和标准差 3通道分别需要需要3个值(输入0到1 则输出为-1到1 看归一化公式)
trans_norm=transforms.Normalize([1,3,5],[3,0.5,0.5])
img_norm=trans_norm(img_tensor)
print(img_norm[0][0][0])
writer.add_image("norm",img_tensor)

#resize
print(img.size)
trans_resize=transforms.Resize((512,512))
img_resize=trans_resize(img)
print(img_resize)
img_resize_tensor=tensor_trans(img_resize)
writer.add_image("resize",img_resize_tensor)


#compose-resize 等比缩放？？
trans_resize2=transforms.Resize(512)
#resize 和 转换成tensor
trans_compose=transforms.Compose([trans_resize2,tensor_trans])

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

writer.close()

三、tensorboard图片显示

import numpy
from tensorboardX import SummaryWriter
from PIL import Image
import  numpy as np
#固定写法 生成logs图片
writer = SummaryWriter("logs")

img_path=r'F:\programming study\hymenoptera_data\train\ants\0013035.jpg'
#打开图
img_pil=Image.open(img_path)
#转换成array
img_array=numpy.array(img_pil)
#图片形状问题 ：dataformats='HWC' 通道在后面
writer.add_image("tupian",img_array,1,dataformats='HWC')



#
# #y=x 绘制
# for i in range(100):
#     writer.add_scalar("y=x",i,i)

# tensorboard --logdir==logs  在终端使用产生图
# tensorboard --logdir==logs --port=6007 指定终端
# tensorboard --logdir ”F:\programming study\logs“ --host=127.0.0.1  使用这个才能运行成功
# opencv 将pil图片 转化为numpy型

writer.close()

四、dataloader CIFAR10数据集使用方法

import torchvision

# 将torchvision数据tensor化 ：transforms.Compose([])
from tensorboardX import SummaryWriter

dataset_transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor()])
train_data=torchvision.datasets.CIFAR10(root='./dataset',train=True,transform=dataset_transform,download=True)
test_data=torchvision.datasets.CIFAR10(root='./dataset',train=False,transform=dataset_transform,download=True)

# # img,label=test_data[1]
# # print(img)
# 打印所有类别
# # print(test_data.classes)
# (test_data[0])直接就包含图片及 种类
print(test_data[0])

writer=SummaryWriter("p10")

for i in range(10):
    img,target=test_data[i]
    #global step i 显示每张图片是什么
    writer.add_image("test_data",img,i)


# 终端命令 tensorboard --logdir ”F:\programming study\p10“ --host=127.0.0.1
writer.close()

五、nn.module 简单模型实现

import torch
from torch import nn

class model(nn.Module):
    #点击code generate 可以实现overwrite 一键复写功能
    def __init__(self) -> None:
        super().__init__()

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

#创建网络
model1=model()
x=torch.tensor(1)
output=model1(x)

print(output)

六、卷积操作

tensor([[ ]]) 有两个中括号就表示二维

reshape（1,1,4,4）banchsize=1（一个平面）通道为1 4*4矩阵

import torch
import torchvision
from tensorboardX import SummaryWriter
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader

dataset_transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor()])
dataset=torchvision.datasets.CIFAR10(root='./dataset',train=True,transform=dataset_transform,download=True)
dataloader=DataLoader(dataset,batch_size=64)#一次加载64张

class model(nn.Module):
    #点击code generate 可以实现overwrite 一键复写功能
    def __init__(self) -> None:
        super().__init__()
        self.conv1=Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)

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

writer = SummaryWriter("logs")

#创建网络
model1=model()

for data in dataloader:
    img,label=data
    output=model1(img)
    print(output.shape)

    #//torch.Size([64, 6, 30, 30]) 输入输出shape不一样 需要转换
    #[-1, 6, 30, 30]  -1 让机器自己配置batchsize
    output=torch.reshape(output,(-1, 3, 30, 30))
    print(output.shape)
    writer.add_images("img",img,global_step=1)
    writer.add_images("output",output, global_step=1)



writer.close()

根据上图计算论文推导

六、池化操作

最大池化只提取特征占比最大的部分减少计算参数

floor模式保存最小值

ceil模式保存最大值

例子

输入输出图像尺寸

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

#不允許處理long  轉換dtype=torch.float32  转化成浮点
input=torch.tensor([[1,2,0,4,1],
                    [0,1,2,3,1],
                    [2,1,2,1,3],
                    [3,4,3,2,1],
                    [2,3,4,1,3]],dtype=torch.float32)



input=torch.reshape(input,[-1,1,5,5])

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

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


model1=model()
model1(input)

七、线性层

import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader


dataset = torchvision.datasets.CIFAR10(root="dataset", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)

dataloader = DataLoader(dataset, batch_size=64)




class linear(nn.Module):
    def __init__(self):
        super(linear, self).__init__()
        self.linear=Linear(196688,20)

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

module=linear()

for data in dataloader:
    imgs, targets=data
    print(imgs.shape)

    #哪是-1 自动计算哪项
    #每一张图片 3*3 例如变成1*9 展成一维 banchsize=1 1通道 1*N
    # 相当于flatten展平
    output = torch.reshape(imgs, (1, 1, 1, -1))

    # output=torch.flatten(imgs)
    print(output.shape)
    # output=module(output)
    # print(output.shape)

八。Sequential

计算padding 和步长默认dilation=1 kernal_size为5 stride=1(因为=2时上面padding扩展64不合理)

得到padding=2

检查网络

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Linear, Flatten


class model(nn.Module):
    def __init__(self):
        super(model, self).__init__()
        self.conv1=Conv2d(3,32,5,padding=2,dilation=1)
        self.maxpool1=MaxPool2d(2)
        self.conv2=Conv2d(32,32,5,padding=2,dilation=1)
        self.maxpool2=MaxPool2d(2)
        self.conv3=Conv2d(32,64,5,padding=2,dilation=1)
        self.maxpool3 = MaxPool2d(2)
        self.flatten=Flatten()
        self.linear1=Linear(1024,64)
        #输入64个类别 输出10个类别
        self.linear2 = Linear(64,10)

    def forward(self,x):
        x=self.conv1(x)
        x=self.maxpool1(x)
        x=self.conv2(x)
        x=self.maxpool2(x)
        x=self.conv3(x)
        x=self.maxpool3(x)
        x=self.flatten(x)
        x=self.linear1(x)
        x=self.linear2(x)
        return x


model1=model()
print(model1)
#检查网络
input=torch.ones((64,3,32,32))
output=model1(input)
print(output)

1024 是自己计算的 64*4*4 如果不想算注释掉

x=self.linear1(x)
x=self.linear2(x)

可以看到输出结果里直接产生1024

简便：使用Sequential

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Linear, Flatten, Sequential


class model(nn.Module):
    def __init__(self):
        super(model, self).__init__()
  

        self.model2=Sequential(
            Conv2d(3, 32, 5, padding=2, dilation=1),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2, dilation=1),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2, dilation=1),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )




    def forward(self,x):
     
        x=self.model2(x)
        return x


model1=model()
print(model1)
#检查网络
input=torch.ones((64,3,32,32))
output=model1(input)
print(output)

损失函数

交叉熵