面向对象的编程（OOP）中重要概念理解
类
概念理解：
一个抽象的模板，定义一类东西的属性和方法。
案例理解：
比如car是一类东西（一个类），可以给car定义颜色（color）、品牌（brand）、速度（speed）等属性，可以给car定义启动（start）、停车（stop）、加速（accelarate）等方法。
代码理解：
# 定义一个父类 Car
class Car:
def __init__(self, color, brand):
self.color = color # 属性：颜色
self.brand = brand # 属性：品牌
self.speed = 0 # 属性：速度
def start(self):
print(f"{self.color}的{self.brand}启动了！")
def accelerate(self, speed_increase):
self.speed += speed_increase
print(f"速度增加到 {self.speed} 公里/小时")
对象
概念理解：
基于类定义的属性和方法，建立的一个具体的实例
案例理解：
比如说对象1是一辆时速为100km/h的白色甲壳虫，对象2为一辆时速为20km/h的蓝色天籁。
代码理解：
# 创建一个 Car 的对象
my_car = Car(color="红色", brand="宝马")
my_car.start() # 输出：红色的宝马启动了！
my_car.accelerate(100) # 输出：速度增加到 100 公里/小时
此处首先初始化了一个对象my_car：红色的宝马
这个my_car可以使用car类中定义的所有方法（start、accelerate）
继承
概念理解：
一种代码复用的机制，子类可以继承父类的属性和行为，并添加新的特性
案例理解：
比如我们新定义一个子类sportscar，他有父类car已经定义的那些属性和方法，就称为这个子类继承了这个父类；此外，这个子类还可以增加一些属性和方法，详见以下代码案例。
代码案例：
# 定义一个子类 SportsCar，继承自 Car
class SportsCar(Car):
def __init__(self, color, brand, turbo):
super().__init__(color, brand) # 继承父类的属性
self.turbo = turbo # 新增属性：涡轮增压
def drift(self):
print(f"{self.color}的{self.brand}正在漂移！")
# 创建一个 SportsCar 的对象
my_sports_car = SportsCar(color="蓝色", brand="法拉利", turbo=True)
my_sports_car.start() # 输出：蓝色的法拉利启动了！
my_sports_car.accelerate(200) # 输出：速度增加到 200 公里/小时
my_sports_car.drift() # 输出：蓝色的法拉利正在漂移！
_init_：
是python的类中第一个方法，它是唯一一个特殊的方法，被称为构造方法（Constructor）。它的作用就是给这一类东西初始化一些属性，当你基于这个类建立一个具体的东西（也就是对象）时，这个方法会自动执行，以确保这个具体的东西拥有这类东西已经定义好的那些基本属性（比如颜色、品牌等）。
self：
这是一个关键字，是类方法的第一个参数，用于在类的方法中引用 当前对象本身。
super()：
这是一个内置函数，用于调用父类的方法，实现代码复用。它通常用于子类的 __init__ 方法中，以便初始化父类的属性。
最后，以一个基于深度学习的图像识别模型训练工程案例代码，来直观展示这些类和对象的概念的运行原理和用法：
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# 定义数据加载器类
class DatasetLoader:
def __init__(self, batch_size=64, num_workers=2):
self.batch_size = batch_size
self.num_workers = num_workers
self.transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
def load_cifar10(self):
# 下载和加载训练集
train_set = torchvision.datasets.CIFAR10(
root='./data', train=True, download=True, transform=self.transform
)
train_loader = DataLoader(
train_set, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers
)
# 下载和加载测试集
test_set = torchvision.datasets.CIFAR10(
root='./data', train=False, download=True, transform=self.transform
)
test_loader = DataLoader(
test_set, batch_size=self.batch_size, shuffle=False, num_workers=self.num_workers
)
return train_loader, test_loader
# 定义基础图像分类器类
class ImageClassifier:
def __init__(self, num_classes=10, learning_rate=0.001):
self.num_classes = num_classes
self.learning_rate = learning_rate
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.model = self._build_model().to(self.device)
self.criterion = nn.CrossEntropyLoss()
self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)
def _build_model(self):
# 定义一个简单的卷积神经网络
return nn.Sequential(
nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Flatten(),
nn.Linear(64 * 8 * 8, 512),
nn.ReLU(),
nn.Linear(512, self.num_classes)
)
def train(self, train_loader, num_epochs=10):
self.model.train()
for epoch in range(num_epochs):
running_loss = 0.0
for images, labels in train_loader:
images = images.to(self.device)
labels = labels.to(self.device)
# 前向传播
outputs = self.model(images)
loss = self.criterion(outputs, labels)
# 反向传播和优化
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
running_loss += loss.item()
print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}")
def evaluate(self, test_loader):
self.model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
images = images.to(self.device)
labels = labels.to(self.device)
outputs = self.model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f"Accuracy of the model on the test images: {accuracy:.2f}%")
# 定义高级图像分类器类（继承自 ImageClassifier）
class AdvancedImageClassifier(ImageClassifier):
def __init__(self, num_classes=10, learning_rate=0.001, use_data_augmentation=True):
super().__init__(num_classes, learning_rate)
self.use_data_augmentation = use_data_augmentation
self.scheduler = optim.lr_scheduler.StepLR(self.optimizer, step_size=5, gamma=0.1)
def _build_model(self):
# 定义一个更复杂的卷积神经网络
return nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Flatten(),
nn.Linear(128 * 8 * 8, 1024),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(1024, self.num_classes)
)
def train(self, train_loader, num_epochs=10):
# 添加数据增强
if self.use_data_augmentation:
print("Using data augmentation...")
train_loader.dataset.transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(10),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
super().train(train_loader, num_epochs)
# 使用学习率调度器
for epoch in range(num_epochs):
self.scheduler.step()
# 主函数
if __name__ == "__main__":
# 加载数据
dataset_loader = DatasetLoader(batch_size=128)
train_loader, test_loader = dataset_loader.load_cifar10()
# 创建基础分类器并训练
print("Training basic classifier...")
basic_classifier = ImageClassifier(num_classes=10, learning_rate=0.001)
basic_classifier.train(train_loader, num_epochs=10)
basic_classifier.evaluate(test_loader)
# 创建高级分类器并训练
print("\nTraining advanced classifier with data augmentation and learning rate scheduling...")
advanced_classifier = AdvancedImageClassifier(num_classes=10, learning_rate=0.001)
advanced_classifier.train(train_loader, num_epochs=10)
advanced_classifier.evaluate(test_loader)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
