【分类|回归】深度学习中的分类和回归？离散数据or连续数值？

news2024/11/19 20:21:34

【分类|回归】深度学习中的分类和回归？离散数据or连续数值？

文章目录

【分类|回归】深度学习中的分类和回归？离散数据or连续数值？
前言
1.分类问题
- 1.1分类问题的定义
- 1.2深度学习中的分类问题
- 1.3实际分类问题及代码示例：手写数字识别（MNIST）
- 1.4分类问题的处理方法
2.回归问题
- 2.1回归问题的定义
- 2.2深度学习中的回归问题
- 2.3实际回归问题及代码示例：房价预测
- 2.4回归问题的处理方法
总结

前言

在机器学习和深度学习中，分类问题和回归问题是两类基本任务。两者的区别在于输出的类型：分类问题的输出是离散的类别标签，而回归问题的输出是连续的数值。

1.分类问题

1.1分类问题的定义

分类问题是指给定输入数据，模型需要将其划分为多个类别中的一个。例如，判断一张图片是猫还是狗，这是一个二分类问题（Binary Classification）；而预测一幅手写数字图片的数字是0到9中的哪个，这是多分类问题（Multiclass Classification）。

1.2深度学习中的分类问题

深度学习处理分类问题的常用方法是使用神经网络模型，尤其是卷积神经网络（CNN），如果是图像处理问题。在分类问题中，最后一层通常是Softmax激活函数，将网络输出转换为概率分布，表示属于每个类别的概率。

1.3实际分类问题及代码示例：手写数字识别（MNIST）

MNIST 是一个手写数字数据集，包含 28x28 的灰度图像和对应的类别标签（0-9）。

代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 定义一个简单的卷积神经网络
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.fc1 = nn.Linear(64*7*7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(torch.relu(self.conv2(x)), 2)
        x = x.view(-1, 64*7*7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return torch.log_softmax(x, dim=1)

# 数据预处理和加载
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

# 定义模型、损失函数和优化器
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(1, 6):
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item()}')

代码解释：

1.定义卷积神经网络：SimpleCNN 是一个简单的CNN，用于处理图像数据，包含两个卷积层和两个全连接层。最后一层输出的维度为10，表示10个类别（数字0到9）。
2.前向传播（forward）：图像输入后经过卷积、池化、展平，再经过全连接层，最后通过 log_softmax 输出每个类别的对数概率。
3.数据预处理：使用 transforms.ToTensor 将图像数据转换为张量，并进行归一化。
4.损失函数：使用交叉熵损失函数 CrossEntropyLoss，适合多分类问题。
5.优化器：Adam优化器用于梯度更新。
6.模型训练：循环训练模型，计算损失并进行梯度更新。

1.4分类问题的处理方法

模型选择：适合分类的模型有逻辑回归（LR）、支持向量机（SVM）、决策树、随机森林等，深度学习中常用的是神经网络。
激活函数：最后一层通常使用 Softmax 激活函数，将模型输出的值转换为概率分布。
损失函数：交叉熵损失函数适合分类任务。

2.回归问题

2.1回归问题的定义

回归问题的目标是预测一个连续的数值。典型的回归问题包括预测房价、股票价格、温度等。例如，给定一个地区的房屋面积、卧室数量等特征，预测房屋的价格。

2.2深度学习中的回归问题

在回归问题中，深度学习模型通常使用全连接神经网络（Fully Connected Neural Networks），输出层的激活函数可以是线性函数（Linear Activation），输出一个连续值。

2.3实际回归问题及代码示例：房价预测

假设我们使用一个简化的数据集，包含房屋面积、卧室数量等特征，来预测房价。

代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 创建简单的回归模型
class SimpleRegressionModel(nn.Module):
    def __init__(self):
        super(SimpleRegressionModel, self).__init__()
        self.fc1 = nn.Linear(2, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)  # 回归输出不需要激活函数
        return x

# 模拟房价数据 (面积, 卧室数量)
data = np.array([[1200, 3], [1500, 4], [1700, 3], [2100, 4], [2500, 5]], dtype=np.float32)
prices = np.array([300000, 400000, 425000, 525000, 600000], dtype=np.float32)

# 转换为PyTorch的张量
data_tensor = torch.from_numpy(data)
prices_tensor = torch.from_numpy(prices).view(-1, 1)

# 定义模型、损失函数和优化器
model = SimpleRegressionModel()
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.Adam(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(1, 101):
    optimizer.zero_grad()
    output = model(data_tensor)
    loss = criterion(output, prices_tensor)
    loss.backward()
    optimizer.step()
    if epoch % 10 == 0:
        print(f'Epoch {epoch}, Loss: {loss.item()}')