DAY 39 图像数据与显存

1. 模型参数+梯度参数
2. 优化器参数
3. 数据批量所占显存
4. 神经元输出中间状态

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader , Dataset
from torchvision import datasets, transforms
import matplotlib.pyplot as plt

torch.manual_seed(42)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    transform=transform
)
sample_idx = torch.randint(0, len(train_dataset), size=(1,)).item() 
image, label = train_dataset[sample_idx] 
def imshow(img):
    img = img* 0.3081 + 0.1307
    npimg= img.numpy()
    plt.imshow(npimg[0], cmap='gray')
    plt.show()
print(f'Label:{label}')
imshow(image)
import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

torch.manual_seed(42)
transform = transforms.Compose([
    transforms.ToTensor(), 
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  
])

trainset = torchvision.datasets.CIFAR10(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

trainloader = torch.utils.data.DataLoader(
    trainset,
    batch_size=4,
    shuffle=True
)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 
           'dog', 'frog', 'horse', 'ship', 'truck')

sample_idx = torch.randint(0, len(trainset), size=(1,)).item()
image, label = trainset[sample_idx]

print(f"图像形状: {image.shape}") 
print(f"图像类别: {classes[label]}")

def imshow(img):
    img = img / 2 + 0.5 
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))  
    plt.axis('off') 
    plt.show()


imshow(image)
transform = transforms.Compose([
    transforms.ToTensor(), 
    transforms.Normalize((0.1307,), (0.3081,)) 
])
import matplotlib.pyplot as plt

train_dataset = datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=transform
)

test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    transform=transform
)
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.flatten = nn.Flatten()  
        self.layer1 = nn.Linear(784, 128) 
        self.relu = nn.ReLU()  
        self.layer2 = nn.Linear(128, 10)  
        
    def forward(self, x):
        x = self.flatten(x)  
        x = self.layer1(x)   
        x = self.relu(x)    
        x = self.layer2(x) 
        return x

model = MLP()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)  

from torchsummary import summary  
print("\n模型结构信息：")
summary(model, input_size=(1, 28, 28)) 
class MLP(nn.Module):
    def __init__(self, input_size=3072, hidden_size=128, num_classes=10):
        super(MLP, self).__init__()

        self.flatten = nn.Flatten()

        self.fc1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes) 
        
    def forward(self, x):
        x = self.flatten(x)  
        x = self.fc1(x)    
        x = self.relu(x)     
        x = self.fc2(x)     
        return x

model = MLP()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device) 
from torchsummary import summary 
print("\n模型结构信息：")
summary(model, input_size=(3, 32, 32))  
    class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten() 
        self.layer1 = nn.Linear(784, 128)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(128, 10)
        
    def forward(self, x):
        x = self.flatten(x) 
        x = self.layer1(x) 
        x = self.relu(x)
        x = self.layer2(x)   
        return x
from torch.utils.data import DataLoader

train_loader = DataLoader(
    dataset=train_dataset,  
    batch_size=64,          
    shuffle=True           
)

test_loader = DataLoader(
    dataset=test_dataset,
    batch_size=1000,
    shuffle=False
)